// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// version: proto synapse v1.0.0

package grpcapi

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// TaskServiceClient is the client API for TaskService
type TaskServiceClient interface {
	// SubmitTask submits a new task
	SubmitTask(ctx context.Context, in *SubmitTaskRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error)
	// SubmitTaskWithFiles submits a task with file attachments
	SubmitTaskWithFiles(ctx context.Context, in *SubmitTaskWithFilesRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error)
	// GetTask gets task details
	GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error)
	// GetTaskStatus gets simplified task status
	GetTaskStatus(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error)
	// ListTasks lists tasks with filtering
	ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error)
	// CancelTask cancels a task
	CancelTask(ctx context.Context, in *CancelTaskRequest, opts ...grpc.CallOption) (*CancelTaskResponse, error)
	// StreamTaskStatus streams task status updates (bidirectional streaming)
	StreamTaskStatus(ctx context.Context, opts ...grpc.CallOption) (TaskService_StreamTaskStatusClient, error)
}

type taskServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient {
	return &taskServiceClient{cc}
}

func (c *taskServiceClient) SubmitTask(ctx context.Context, in *SubmitTaskRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error) {
	out := new(SubmitTaskResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/SubmitTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) SubmitTaskWithFiles(ctx context.Context, in *SubmitTaskWithFilesRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error) {
	out := new(SubmitTaskResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/SubmitTaskWithFiles", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error) {
	out := new(TaskStatusResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/GetTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) GetTaskStatus(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error) {
	out := new(TaskStatusResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/GetTaskStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) {
	out := new(ListTasksResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/ListTasks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) CancelTask(ctx context.Context, in *CancelTaskRequest, opts ...grpc.CallOption) (*CancelTaskResponse, error) {
	out := new(CancelTaskResponse)
	err := c.cc.Invoke(ctx, "/a2a.TaskService/CancelTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) StreamTaskStatus(ctx context.Context, opts ...grpc.CallOption) (TaskService_StreamTaskStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &TaskService_ServiceDesc.Streams[0], "/a2a.TaskService/StreamTaskStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &taskServiceStreamTaskStatusClient{stream}
	return x, nil
}

type TaskService_StreamTaskStatusClient interface {
	Send(*TaskStatusStreamRequest) error
	Recv() (*TaskStatusUpdate, error)
	grpc.ClientStream
}

type taskServiceStreamTaskStatusClient struct {
	grpc.ClientStream
}

func (x *taskServiceStreamTaskStatusClient) Send(m *TaskStatusStreamRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// TaskServiceServer is the server API for TaskService
type TaskServiceServer interface {
	SubmitTask(context.Context, *SubmitTaskRequest) (*SubmitTaskResponse, error)
	SubmitTaskWithFiles(context.Context, *SubmitTaskWithFilesRequest) (*SubmitTaskResponse, error)
	GetTask(context.Context, *GetTaskRequest) (*TaskStatusResponse, error)
	GetTaskStatus(context.Context, *GetTaskRequest) (*TaskStatusResponse, error)
	ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error)
	CancelTask(context.Context, *CancelTaskRequest) (*CancelTaskResponse, error)
	StreamTaskStatus(TaskService_StreamTaskStatusServer) error
}

// UnimplementedTaskServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTaskServiceServer struct {
}

func (UnimplementedTaskServiceServer) SubmitTask(context.Context, *SubmitTaskRequest) (*SubmitTaskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitTask not implemented")
}

func (UnimplementedTaskServiceServer) SubmitTaskWithFiles(context.Context, *SubmitTaskWithFilesRequest) (*SubmitTaskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitTaskWithFiles not implemented")
}

func (UnimplementedTaskServiceServer) GetTask(context.Context, *GetTaskRequest) (*TaskStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTask not implemented")
}

func (UnimplementedTaskServiceServer) GetTaskStatus(context.Context, *GetTaskRequest) (*TaskStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTaskStatus not implemented")
}

func (UnimplementedTaskServiceServer) ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTasks not implemented")
}

func (UnimplementedTaskServiceServer) CancelTask(context.Context, *CancelTaskRequest) (*CancelTaskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelTask not implemented")
}

func (UnimplementedTaskServiceServer) StreamTaskStatus(TaskService_StreamTaskStatusServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamTaskStatus not implemented")
}

type TaskService_StreamTaskStatusServer interface {
	Send(*TaskStatusUpdate) error
	Recv() (*TaskStatusStreamRequest, error)
	grpc.ServerStream
}

type taskServiceStreamStatusServer struct {
	grpc.ServerStream
}

func (x *taskServiceStreamStatusServer) Send(m *TaskStatusUpdate) error {
	return x.ServerStream.SendMsg(m)
}

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

// TaskService_ServiceDesc is the grpc.ServiceDesc for TaskService
var TaskService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "a2a.TaskService",
	HandlerType: (*TaskServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SubmitTask",
			Handler:    _TaskService_SubmitTask_Handler,
		},
		{
			MethodName: "SubmitTaskWithFiles",
			Handler:    _TaskService_SubmitTaskWithFiles_Handler,
		},
		{
			MethodName: "GetTask",
			Handler:    _TaskService_GetTask_Handler,
		},
		{
			MethodName: "GetTaskStatus",
			Handler:    _TaskService_GetTaskStatus_Handler,
		},
		{
			MethodName: "ListTasks",
			Handler:    _TaskService_ListTasks_Handler,
		},
		{
			MethodName: "CancelTask",
			Handler:    _TaskService_CancelTask_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamTaskStatus",
			Handler:       _TaskService_StreamTaskStatus_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "a2a.proto",
}

func _TaskService_SubmitTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).SubmitTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/SubmitTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).SubmitTask(ctx, req.(*SubmitTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_SubmitTaskWithFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitTaskWithFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).SubmitTaskWithFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/SubmitTaskWithFiles",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).SubmitTaskWithFiles(ctx, req.(*SubmitTaskWithFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_GetTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).GetTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/GetTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).GetTask(ctx, req.(*GetTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_GetTaskStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).GetTaskStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/GetTaskStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).GetTaskStatus(ctx, req.(*GetTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_ListTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTasksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).ListTasks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/ListTasks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).ListTasks(ctx, req.(*ListTasksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_CancelTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).CancelTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.TaskService/CancelTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).CancelTask(ctx, req.(*CancelTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_StreamTaskStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TaskServiceServer).StreamTaskStatus(&taskServiceStreamStatusServer{ServerStream: stream})
}

// =============================================================================
// A2AMessageService
// =============================================================================

// A2AMessageServiceClient is the client API for A2AMessageService
type A2AMessageServiceClient interface {
	// SendMessage sends a single Synapse message
	SendMessage(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*SendMessageResponse, error)
	// StreamMessages streams Synapse messages (bidirectional streaming)
	StreamMessages(ctx context.Context, opts ...grpc.CallOption) (A2AMessageService_StreamMessagesClient, error)
	// ReceiveCallback receives callback messages (server streaming)
	ReceiveCallback(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (A2AMessageService_ReceiveCallbackClient, error)
}

type a2aMessageServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewA2AMessageServiceClient(cc grpc.ClientConnInterface) A2AMessageServiceClient {
	return &a2aMessageServiceClient{cc}
}

func (c *a2aMessageServiceClient) SendMessage(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*SendMessageResponse, error) {
	out := new(SendMessageResponse)
	err := c.cc.Invoke(ctx, "/a2a.A2AMessageService/SendMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *a2aMessageServiceClient) StreamMessages(ctx context.Context, opts ...grpc.CallOption) (A2AMessageService_StreamMessagesClient, error) {
	stream, err := c.cc.NewStream(ctx, &A2AMessageService_ServiceDesc.Streams[0], "/a2a.A2AMessageService/StreamMessages", opts...)
	if err != nil {
		return nil, err
	}
	x := &a2aMessageServiceStreamMessagesClient{stream}
	return x, nil
}

type A2AMessageService_StreamMessagesClient interface {
	Send(*A2AMessage) error
	Recv() (*A2AMessage, error)
	grpc.ClientStream
}

type a2aMessageServiceStreamMessagesClient struct {
	grpc.ClientStream
}

func (x *a2aMessageServiceStreamMessagesClient) Send(m *A2AMessage) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *a2aMessageServiceClient) ReceiveCallback(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (A2AMessageService_ReceiveCallbackClient, error) {
	stream, err := c.cc.NewStream(ctx, &A2AMessageService_ServiceDesc.Streams[1], "/a2a.A2AMessageService/ReceiveCallback", opts...)
	if err != nil {
		return nil, err
	}
	x := &a2aMessageServiceReceiveCallbackClient{stream}
	return x, nil
}

type A2AMessageService_ReceiveCallbackClient interface {
	Recv() (*A2AMessage, error)
	grpc.ClientStream
}

type a2aMessageServiceReceiveCallbackClient struct {
	grpc.ClientStream
}

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

// A2AMessageServiceServer is the server API for A2AMessageService
type A2AMessageServiceServer interface {
	SendMessage(context.Context, *SendMessageRequest) (*SendMessageResponse, error)
	StreamMessages(A2AMessageService_StreamMessagesServer) error
	ReceiveCallback(*emptypb.Empty, A2AMessageService_ReceiveCallbackServer) error
}

// UnimplementedA2AMessageServiceServer can be embedded to have forward compatible implementations.
type UnimplementedA2AMessageServiceServer struct {
}

func (UnimplementedA2AMessageServiceServer) SendMessage(context.Context, *SendMessageRequest) (*SendMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendMessage not implemented")
}

func (UnimplementedA2AMessageServiceServer) StreamMessages(A2AMessageService_StreamMessagesServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamMessages not implemented")
}

func (UnimplementedA2AMessageServiceServer) ReceiveCallback(*emptypb.Empty, A2AMessageService_ReceiveCallbackServer) error {
	return status.Errorf(codes.Unimplemented, "method ReceiveCallback not implemented")
}

type A2AMessageService_StreamMessagesServer interface {
	Send(*A2AMessage) error
	Recv() (*A2AMessage, error)
	grpc.ServerStream
}

type a2aMessageServiceStreamMessagesServer struct {
	grpc.ServerStream
}

func (x *a2aMessageServiceStreamMessagesServer) Send(m *A2AMessage) error {
	return x.ServerStream.SendMsg(m)
}

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

type A2AMessageService_ReceiveCallbackServer interface {
	Send(*A2AMessage) error
	grpc.ServerStream
}

type a2aMessageServiceReceiveCallbackServer struct {
	grpc.ServerStream
}

func (x *a2aMessageServiceReceiveCallbackServer) Send(m *A2AMessage) error {
	return x.ServerStream.SendMsg(m)
}

// A2AMessageService_ServiceDesc is the grpc.ServiceDesc for A2AMessageService
var A2AMessageService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "a2a.A2AMessageService",
	HandlerType: (*A2AMessageServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SendMessage",
			Handler:    _A2AMessageService_SendMessage_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamMessages",
			Handler:       _A2AMessageService_StreamMessages_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "ReceiveCallback",
			Handler:       _A2AMessageService_ReceiveCallback_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "a2a.proto",
}

func _A2AMessageService_SendMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(A2AMessageServiceServer).SendMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.A2AMessageService/SendMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(A2AMessageServiceServer).SendMessage(ctx, req.(*SendMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _A2AMessageService_StreamMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(A2AMessageServiceServer).StreamMessages(&a2aMessageServiceStreamMessagesServer{ServerStream: stream})
}

func _A2AMessageService_ReceiveCallback_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(A2AMessageServiceServer).ReceiveCallback(m, &a2aMessageServiceReceiveCallbackServer{ServerStream: stream})
}

// =============================================================================
// CapabilitiesService
// =============================================================================

// CapabilitiesServiceClient is the client API for CapabilitiesService
type CapabilitiesServiceClient interface {
	GetCapabilities(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error)
	QueryAgent(ctx context.Context, in *QueryAgentRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error)
	ListAgents(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListAgentsResponse, error)
}

type capabilitiesServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCapabilitiesServiceClient(cc grpc.ClientConnInterface) CapabilitiesServiceClient {
	return &capabilitiesServiceClient{cc}
}

func (c *capabilitiesServiceClient) GetCapabilities(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) {
	out := new(CapabilitiesResponse)
	err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/GetCapabilities", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *capabilitiesServiceClient) QueryAgent(ctx context.Context, in *QueryAgentRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) {
	out := new(CapabilitiesResponse)
	err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/QueryAgent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *capabilitiesServiceClient) ListAgents(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListAgentsResponse, error) {
	out := new(ListAgentsResponse)
	err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/ListAgents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CapabilitiesServiceServer is the server API for CapabilitiesService
type CapabilitiesServiceServer interface {
	GetCapabilities(context.Context, *emptypb.Empty) (*CapabilitiesResponse, error)
	QueryAgent(context.Context, *QueryAgentRequest) (*CapabilitiesResponse, error)
	ListAgents(context.Context, *emptypb.Empty) (*ListAgentsResponse, error)
}

// UnimplementedCapabilitiesServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCapabilitiesServiceServer struct {
}

func (UnimplementedCapabilitiesServiceServer) GetCapabilities(context.Context, *emptypb.Empty) (*CapabilitiesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCapabilities not implemented")
}

func (UnimplementedCapabilitiesServiceServer) QueryAgent(context.Context, *QueryAgentRequest) (*CapabilitiesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryAgent not implemented")
}

func (UnimplementedCapabilitiesServiceServer) ListAgents(context.Context, *emptypb.Empty) (*ListAgentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAgents not implemented")
}

// CapabilitiesService_ServiceDesc is the grpc.ServiceDesc for CapabilitiesService
var CapabilitiesService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "a2a.CapabilitiesService",
	HandlerType: (*CapabilitiesServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCapabilities",
			Handler:    _CapabilitiesService_GetCapabilities_Handler,
		},
		{
			MethodName: "QueryAgent",
			Handler:    _CapabilitiesService_QueryAgent_Handler,
		},
		{
			MethodName: "ListAgents",
			Handler:    _CapabilitiesService_ListAgents_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "a2a.proto",
}

func _CapabilitiesService_GetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CapabilitiesServiceServer).GetCapabilities(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.CapabilitiesService/GetCapabilities",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CapabilitiesServiceServer).GetCapabilities(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _CapabilitiesService_QueryAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAgentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CapabilitiesServiceServer).QueryAgent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.CapabilitiesService/QueryAgent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CapabilitiesServiceServer).QueryAgent(ctx, req.(*QueryAgentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CapabilitiesService_ListAgents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CapabilitiesServiceServer).ListAgents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/a2a.CapabilitiesService/ListAgents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CapabilitiesServiceServer).ListAgents(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// =============================================================================
// GroupService
// =============================================================================

// GroupServiceClient is the client API for GroupService
type GroupServiceClient interface {
	CreateGroup(ctx context.Context, in *CreateGroupRequest, opts ...grpc.CallOption) (*CreateGroupResponse, error)
	JoinGroup(ctx context.Context, in *JoinGroupRequest, opts ...grpc.CallOption) (*JoinGroupResponse, error)
	LeaveGroup(ctx context.Context, in *LeaveGroupRequest, opts ...grpc.CallOption) (*LeaveGroupResponse, error)
	DisbandGroup(ctx context.Context, in *DisbandGroupRequest, opts ...grpc.CallOption) (*DisbandGroupResponse, error)
	ListGroupMembers(ctx context.Context, in *ListGroupMembersRequest, opts ...grpc.CallOption) (*ListGroupMembersResponse, error)
	StreamGroupMessages(ctx context.Context, opts ...grpc.CallOption) (GroupService_StreamGroupMessagesClient, error)
	// Voting
	InitiateVote(ctx context.Context, in *VoteRequest, opts ...grpc.CallOption) (*VoteResponse, error)
	SubmitVote(ctx context.Context, in *SubmitVoteRequest, opts ...grpc.CallOption) (*SubmitVoteResponse, error)
	GetVoteStatus(ctx context.Context, in *GetVoteStatusRequest, opts ...grpc.CallOption) (*VoteStatusResponse, error)
	// Task Split
	SplitTask(ctx context.Context, in *SplitTaskRequest, opts ...grpc.CallOption) (*SplitTaskResponse, error)
	MergeResults(ctx context.Context, in *MergeResultsRequest, opts ...grpc.CallOption) (*MergeResultsResponse, error)
}

type groupServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGroupServiceClient(cc grpc.ClientConnInterface) GroupServiceClient {
	return &groupServiceClient{cc}
}

func (c *groupServiceClient) CreateGroup(ctx context.Context, in *CreateGroupRequest, opts ...grpc.CallOption) (*CreateGroupResponse, error) {
	out := new(CreateGroupResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/CreateGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) JoinGroup(ctx context.Context, in *JoinGroupRequest, opts ...grpc.CallOption) (*JoinGroupResponse, error) {
	out := new(JoinGroupResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/JoinGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) LeaveGroup(ctx context.Context, in *LeaveGroupRequest, opts ...grpc.CallOption) (*LeaveGroupResponse, error) {
	out := new(LeaveGroupResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/LeaveGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) DisbandGroup(ctx context.Context, in *DisbandGroupRequest, opts ...grpc.CallOption) (*DisbandGroupResponse, error) {
	out := new(DisbandGroupResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/DisbandGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) ListGroupMembers(ctx context.Context, in *ListGroupMembersRequest, opts ...grpc.CallOption) (*ListGroupMembersResponse, error) {
	out := new(ListGroupMembersResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/ListGroupMembers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) StreamGroupMessages(ctx context.Context, opts ...grpc.CallOption) (GroupService_StreamGroupMessagesClient, error) {
	stream, err := c.cc.NewStream(ctx, &GroupService_ServiceDesc.Streams[0], "/a2a.GroupService/StreamGroupMessages", opts...)
	if err != nil {
		return nil, err
	}
	x := &groupServiceStreamGroupMessagesClient{stream}
	return x, nil
}

type GroupService_StreamGroupMessagesClient interface {
	Send(*A2AMessage) error
	Recv() (*A2AMessage, error)
	grpc.ClientStream
}

type groupServiceStreamGroupMessagesClient struct {
	grpc.ClientStream
}

func (x *groupServiceStreamGroupMessagesClient) Send(m *A2AMessage) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *groupServiceClient) InitiateVote(ctx context.Context, in *VoteRequest, opts ...grpc.CallOption) (*VoteResponse, error) {
	out := new(VoteResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/InitiateVote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) SubmitVote(ctx context.Context, in *SubmitVoteRequest, opts ...grpc.CallOption) (*SubmitVoteResponse, error) {
	out := new(SubmitVoteResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/SubmitVote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) GetVoteStatus(ctx context.Context, in *GetVoteStatusRequest, opts ...grpc.CallOption) (*VoteStatusResponse, error) {
	out := new(VoteStatusResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/GetVoteStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) SplitTask(ctx context.Context, in *SplitTaskRequest, opts ...grpc.CallOption) (*SplitTaskResponse, error) {
	out := new(SplitTaskResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/SplitTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupServiceClient) MergeResults(ctx context.Context, in *MergeResultsRequest, opts ...grpc.CallOption) (*MergeResultsResponse, error) {
	out := new(MergeResultsResponse)
	err := c.cc.Invoke(ctx, "/a2a.GroupService/MergeResults", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GroupServiceServer is the server API for GroupService
type GroupServiceServer interface {
	CreateGroup(context.Context, *CreateGroupRequest) (*CreateGroupResponse, error)
	JoinGroup(context.Context, *JoinGroupRequest) (*JoinGroupResponse, error)
	LeaveGroup(context.Context, *LeaveGroupRequest) (*LeaveGroupResponse, error)
	DisbandGroup(context.Context, *DisbandGroupRequest) (*DisbandGroupResponse, error)
	ListGroupMembers(context.Context, *ListGroupMembersRequest) (*ListGroupMembersResponse, error)
	StreamGroupMessages(GroupService_StreamGroupMessagesServer) error
	// Voting
	InitiateVote(context.Context, *VoteRequest) (*VoteResponse, error)
	SubmitVote(context.Context, *SubmitVoteRequest) (*SubmitVoteResponse, error)
	GetVoteStatus(context.Context, *GetVoteStatusRequest) (*VoteStatusResponse, error)
	// Task Split
	SplitTask(context.Context, *SplitTaskRequest) (*SplitTaskResponse, error)
	MergeResults(context.Context, *MergeResultsRequest) (*MergeResultsResponse, error)
}

// UnimplementedGroupServiceServer can be embedded to have forward compatible implementations.
type UnimplementedGroupServiceServer struct {
}

func (UnimplementedGroupServiceServer) CreateGroup(context.Context, *CreateGroupRequest) (*CreateGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateGroup not implemented")
}

func (UnimplementedGroupServiceServer) JoinGroup(context.Context, *JoinGroupRequest) (*JoinGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method JoinGroup not implemented")
}

func (UnimplementedGroupServiceServer) LeaveGroup(context.Context, *LeaveGroupRequest) (*LeaveGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LeaveGroup not implemented")
}

func (UnimplementedGroupServiceServer) DisbandGroup(context.Context, *DisbandGroupRequest) (*DisbandGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisbandGroup not implemented")
}

func (UnimplementedGroupServiceServer) ListGroupMembers(context.Context, *ListGroupMembersRequest) (*ListGroupMembersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListGroupMembers not implemented")
}

func (UnimplementedGroupServiceServer) StreamGroupMessages(GroupService_StreamGroupMessagesServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamGroupMessages not implemented")
}

func (UnimplementedGroupServiceServer) InitiateVote(context.Context, *VoteRequest) (*VoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitiateVote not implemented")
}

func (UnimplementedGroupServiceServer) SubmitVote(context.Context, *SubmitVoteRequest) (*SubmitVoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitVote not implemented")
}

func (UnimplementedGroupServiceServer) GetVoteStatus(context.Context, *GetVoteStatusRequest) (*VoteStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVoteStatus not implemented")
}

func (UnimplementedGroupServiceServer) SplitTask(context.Context, *SplitTaskRequest) (*SplitTaskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SplitTask not implemented")
}

func (UnimplementedGroupServiceServer) MergeResults(context.Context, *MergeResultsRequest) (*MergeResultsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MergeResults not implemented")
}

type GroupService_StreamGroupMessagesServer interface {
	Send(*A2AMessage) error
	Recv() (*A2AMessage, error)
	grpc.ServerStream
}

type groupServiceStreamMessagesServer struct {
	grpc.ServerStream
}

func (x *groupServiceStreamMessagesServer) Send(m *A2AMessage) error {
	return x.ServerStream.SendMsg(m)
}

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

// GroupService_ServiceDesc is the grpc.ServiceDesc for GroupService
var GroupService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "a2a.GroupService",
	HandlerType: (*GroupServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{MethodName: "CreateGroup", Handler: _GroupService_CreateGroup_Handler},
		{MethodName: "JoinGroup", Handler: _GroupService_JoinGroup_Handler},
		{MethodName: "LeaveGroup", Handler: _GroupService_LeaveGroup_Handler},
		{MethodName: "DisbandGroup", Handler: _GroupService_DisbandGroup_Handler},
		{MethodName: "ListGroupMembers", Handler: _GroupService_ListGroupMembers_Handler},
		{MethodName: "InitiateVote", Handler: _GroupService_InitiateVote_Handler},
		{MethodName: "SubmitVote", Handler: _GroupService_SubmitVote_Handler},
		{MethodName: "GetVoteStatus", Handler: _GroupService_GetVoteStatus_Handler},
		{MethodName: "SplitTask", Handler: _GroupService_SplitTask_Handler},
		{MethodName: "MergeResults", Handler: _GroupService_MergeResults_Handler},
	},
	Streams: []grpc.StreamDesc{
		{StreamName: "StreamGroupMessages", Handler: _GroupService_StreamGroupMessages_Handler, ServerStreams: true, ClientStreams: true},
	},
	Metadata: "a2a.proto",
}

func _GroupService_CreateGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupServiceServer).CreateGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/CreateGroup"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).CreateGroup(ctx, req.(*CreateGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_JoinGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/JoinGroup"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).JoinGroup(ctx, req.(*JoinGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_LeaveGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LeaveGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/LeaveGroup"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).LeaveGroup(ctx, req.(*LeaveGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_DisbandGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisbandGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/DisbandGroup"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).DisbandGroup(ctx, req.(*DisbandGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_ListGroupMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListGroupMembersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/ListGroupMembers"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).ListGroupMembers(ctx, req.(*ListGroupMembersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_StreamGroupMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GroupServiceServer).StreamGroupMessages(&groupServiceStreamMessagesServer{ServerStream: stream})
}

func _GroupService_InitiateVote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/InitiateVote"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).InitiateVote(ctx, req.(*VoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_SubmitVote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitVoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/SubmitVote"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).SubmitVote(ctx, req.(*SubmitVoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_GetVoteStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVoteStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/GetVoteStatus"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).GetVoteStatus(ctx, req.(*GetVoteStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_SplitTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SplitTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/SplitTask"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).SplitTask(ctx, req.(*SplitTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GroupService_MergeResults_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MergeResultsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/MergeResults"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServiceServer).MergeResults(ctx, req.(*MergeResultsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// =============================================================================
// HealthService
// =============================================================================

// HealthServiceClient is the client API for HealthService
type HealthServiceClient interface {
	HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error)
}

type healthServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewHealthServiceClient(cc grpc.ClientConnInterface) HealthServiceClient {
	return &healthServiceClient{cc}
}

func (c *healthServiceClient) HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
	out := new(HealthCheckResponse)
	err := c.cc.Invoke(ctx, "/a2a.HealthService/HealthCheck", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HealthServiceServer is the server API for HealthService
type HealthServiceServer interface {
	HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error)
}

// UnimplementedHealthServiceServer can be embedded to have forward compatible implementations.
type UnimplementedHealthServiceServer struct {
}

func (UnimplementedHealthServiceServer) HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
}

// HealthService_ServiceDesc is the grpc.ServiceDesc for HealthService
var HealthService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "a2a.HealthService",
	HandlerType: (*HealthServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{MethodName: "HealthCheck", Handler: _HealthService_HealthCheck_Handler},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "a2a.proto",
}

func _HealthService_HealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HealthServiceServer).HealthCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.HealthService/HealthCheck"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HealthServiceServer).HealthCheck(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _ HealthServiceServer = (HealthServiceServer)(nil)

func init() {
	// Register all services
}