// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v5.29.3
// source: daemon.proto

package rpc

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 (
	Daemon_Connect_FullMethodName        = "/rpc.Daemon/Connect"
	Daemon_Disconnect_FullMethodName     = "/rpc.Daemon/Disconnect"
	Daemon_Proxy_FullMethodName          = "/rpc.Daemon/Proxy"
	Daemon_Leave_FullMethodName          = "/rpc.Daemon/Leave"
	Daemon_Sync_FullMethodName           = "/rpc.Daemon/Sync"
	Daemon_Unsync_FullMethodName         = "/rpc.Daemon/Unsync"
	Daemon_ConnectionList_FullMethodName = "/rpc.Daemon/ConnectionList"
	Daemon_ConnectionUse_FullMethodName  = "/rpc.Daemon/ConnectionUse"
	Daemon_SshStart_FullMethodName       = "/rpc.Daemon/SshStart"
	Daemon_SshStop_FullMethodName        = "/rpc.Daemon/SshStop"
	Daemon_Route_FullMethodName          = "/rpc.Daemon/Route"
	Daemon_Logs_FullMethodName           = "/rpc.Daemon/Logs"
	Daemon_Upgrade_FullMethodName        = "/rpc.Daemon/Upgrade"
	Daemon_Status_FullMethodName         = "/rpc.Daemon/Status"
	Daemon_Version_FullMethodName        = "/rpc.Daemon/Version"
	Daemon_Reset_FullMethodName          = "/rpc.Daemon/Reset"
	Daemon_Uninstall_FullMethodName      = "/rpc.Daemon/Uninstall"
	Daemon_Quit_FullMethodName           = "/rpc.Daemon/Quit"
	Daemon_Identify_FullMethodName       = "/rpc.Daemon/Identify"
)

// DaemonClient is the client API for Daemon 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 DaemonClient interface {
	Connect(ctx context.Context, opts ...grpc.CallOption) (Daemon_ConnectClient, error)
	Disconnect(ctx context.Context, opts ...grpc.CallOption) (Daemon_DisconnectClient, error)
	Proxy(ctx context.Context, opts ...grpc.CallOption) (Daemon_ProxyClient, error)
	Leave(ctx context.Context, opts ...grpc.CallOption) (Daemon_LeaveClient, error)
	Sync(ctx context.Context, opts ...grpc.CallOption) (Daemon_SyncClient, error)
	Unsync(ctx context.Context, opts ...grpc.CallOption) (Daemon_UnsyncClient, error)
	ConnectionList(ctx context.Context, in *ConnectionListRequest, opts ...grpc.CallOption) (*ConnectionListResponse, error)
	ConnectionUse(ctx context.Context, in *ConnectionUseRequest, opts ...grpc.CallOption) (*ConnectionUseResponse, error)
	SshStart(ctx context.Context, in *SshStartRequest, opts ...grpc.CallOption) (*SshStartResponse, error)
	SshStop(ctx context.Context, in *SshStopRequest, opts ...grpc.CallOption) (*SshStopResponse, error)
	Route(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteResponse, error)
	Logs(ctx context.Context, opts ...grpc.CallOption) (Daemon_LogsClient, error)
	Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*UpgradeResponse, error)
	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
	Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error)
	Reset(ctx context.Context, opts ...grpc.CallOption) (Daemon_ResetClient, error)
	Uninstall(ctx context.Context, opts ...grpc.CallOption) (Daemon_UninstallClient, error)
	Quit(ctx context.Context, opts ...grpc.CallOption) (Daemon_QuitClient, error)
	Identify(ctx context.Context, in *IdentifyRequest, opts ...grpc.CallOption) (*IdentifyResponse, error)
}

type daemonClient struct {
	cc grpc.ClientConnInterface
}

func NewDaemonClient(cc grpc.ClientConnInterface) DaemonClient {
	return &daemonClient{cc}
}

func (c *daemonClient) Connect(ctx context.Context, opts ...grpc.CallOption) (Daemon_ConnectClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[0], Daemon_Connect_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonConnectClient{stream}
	return x, nil
}

type Daemon_ConnectClient interface {
	Send(*ConnectRequest) error
	Recv() (*ConnectResponse, error)
	grpc.ClientStream
}

type daemonConnectClient struct {
	grpc.ClientStream
}

func (x *daemonConnectClient) Send(m *ConnectRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Disconnect(ctx context.Context, opts ...grpc.CallOption) (Daemon_DisconnectClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[1], Daemon_Disconnect_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonDisconnectClient{stream}
	return x, nil
}

type Daemon_DisconnectClient interface {
	Send(*DisconnectRequest) error
	Recv() (*DisconnectResponse, error)
	grpc.ClientStream
}

type daemonDisconnectClient struct {
	grpc.ClientStream
}

func (x *daemonDisconnectClient) Send(m *DisconnectRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Proxy(ctx context.Context, opts ...grpc.CallOption) (Daemon_ProxyClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[2], Daemon_Proxy_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonProxyClient{stream}
	return x, nil
}

type Daemon_ProxyClient interface {
	Send(*ProxyRequest) error
	Recv() (*ProxyResponse, error)
	grpc.ClientStream
}

type daemonProxyClient struct {
	grpc.ClientStream
}

func (x *daemonProxyClient) Send(m *ProxyRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Leave(ctx context.Context, opts ...grpc.CallOption) (Daemon_LeaveClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[3], Daemon_Leave_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonLeaveClient{stream}
	return x, nil
}

type Daemon_LeaveClient interface {
	Send(*LeaveRequest) error
	Recv() (*LeaveResponse, error)
	grpc.ClientStream
}

type daemonLeaveClient struct {
	grpc.ClientStream
}

func (x *daemonLeaveClient) Send(m *LeaveRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Sync(ctx context.Context, opts ...grpc.CallOption) (Daemon_SyncClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[4], Daemon_Sync_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonSyncClient{stream}
	return x, nil
}

type Daemon_SyncClient interface {
	Send(*SyncRequest) error
	Recv() (*SyncResponse, error)
	grpc.ClientStream
}

type daemonSyncClient struct {
	grpc.ClientStream
}

func (x *daemonSyncClient) Send(m *SyncRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Unsync(ctx context.Context, opts ...grpc.CallOption) (Daemon_UnsyncClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[5], Daemon_Unsync_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonUnsyncClient{stream}
	return x, nil
}

type Daemon_UnsyncClient interface {
	Send(*UnsyncRequest) error
	Recv() (*UnsyncResponse, error)
	grpc.ClientStream
}

type daemonUnsyncClient struct {
	grpc.ClientStream
}

func (x *daemonUnsyncClient) Send(m *UnsyncRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) ConnectionList(ctx context.Context, in *ConnectionListRequest, opts ...grpc.CallOption) (*ConnectionListResponse, error) {
	out := new(ConnectionListResponse)
	err := c.cc.Invoke(ctx, Daemon_ConnectionList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) ConnectionUse(ctx context.Context, in *ConnectionUseRequest, opts ...grpc.CallOption) (*ConnectionUseResponse, error) {
	out := new(ConnectionUseResponse)
	err := c.cc.Invoke(ctx, Daemon_ConnectionUse_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) SshStart(ctx context.Context, in *SshStartRequest, opts ...grpc.CallOption) (*SshStartResponse, error) {
	out := new(SshStartResponse)
	err := c.cc.Invoke(ctx, Daemon_SshStart_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) SshStop(ctx context.Context, in *SshStopRequest, opts ...grpc.CallOption) (*SshStopResponse, error) {
	out := new(SshStopResponse)
	err := c.cc.Invoke(ctx, Daemon_SshStop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) Route(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteResponse, error) {
	out := new(RouteResponse)
	err := c.cc.Invoke(ctx, Daemon_Route_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) Logs(ctx context.Context, opts ...grpc.CallOption) (Daemon_LogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[6], Daemon_Logs_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonLogsClient{stream}
	return x, nil
}

type Daemon_LogsClient interface {
	Send(*LogRequest) error
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type daemonLogsClient struct {
	grpc.ClientStream
}

func (x *daemonLogsClient) Send(m *LogRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*UpgradeResponse, error) {
	out := new(UpgradeResponse)
	err := c.cc.Invoke(ctx, Daemon_Upgrade_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
	out := new(StatusResponse)
	err := c.cc.Invoke(ctx, Daemon_Status_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error) {
	out := new(VersionResponse)
	err := c.cc.Invoke(ctx, Daemon_Version_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *daemonClient) Reset(ctx context.Context, opts ...grpc.CallOption) (Daemon_ResetClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[7], Daemon_Reset_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonResetClient{stream}
	return x, nil
}

type Daemon_ResetClient interface {
	Send(*ResetRequest) error
	Recv() (*ResetResponse, error)
	grpc.ClientStream
}

type daemonResetClient struct {
	grpc.ClientStream
}

func (x *daemonResetClient) Send(m *ResetRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Uninstall(ctx context.Context, opts ...grpc.CallOption) (Daemon_UninstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[8], Daemon_Uninstall_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonUninstallClient{stream}
	return x, nil
}

type Daemon_UninstallClient interface {
	Send(*UninstallRequest) error
	Recv() (*UninstallResponse, error)
	grpc.ClientStream
}

type daemonUninstallClient struct {
	grpc.ClientStream
}

func (x *daemonUninstallClient) Send(m *UninstallRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Quit(ctx context.Context, opts ...grpc.CallOption) (Daemon_QuitClient, error) {
	stream, err := c.cc.NewStream(ctx, &Daemon_ServiceDesc.Streams[9], Daemon_Quit_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &daemonQuitClient{stream}
	return x, nil
}

type Daemon_QuitClient interface {
	Send(*QuitRequest) error
	Recv() (*QuitResponse, error)
	grpc.ClientStream
}

type daemonQuitClient struct {
	grpc.ClientStream
}

func (x *daemonQuitClient) Send(m *QuitRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *daemonClient) Identify(ctx context.Context, in *IdentifyRequest, opts ...grpc.CallOption) (*IdentifyResponse, error) {
	out := new(IdentifyResponse)
	err := c.cc.Invoke(ctx, Daemon_Identify_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DaemonServer is the server API for Daemon service.
// All implementations must embed UnimplementedDaemonServer
// for forward compatibility
type DaemonServer interface {
	Connect(Daemon_ConnectServer) error
	Disconnect(Daemon_DisconnectServer) error
	Proxy(Daemon_ProxyServer) error
	Leave(Daemon_LeaveServer) error
	Sync(Daemon_SyncServer) error
	Unsync(Daemon_UnsyncServer) error
	ConnectionList(context.Context, *ConnectionListRequest) (*ConnectionListResponse, error)
	ConnectionUse(context.Context, *ConnectionUseRequest) (*ConnectionUseResponse, error)
	SshStart(context.Context, *SshStartRequest) (*SshStartResponse, error)
	SshStop(context.Context, *SshStopRequest) (*SshStopResponse, error)
	Route(context.Context, *RouteRequest) (*RouteResponse, error)
	Logs(Daemon_LogsServer) error
	Upgrade(context.Context, *UpgradeRequest) (*UpgradeResponse, error)
	Status(context.Context, *StatusRequest) (*StatusResponse, error)
	Version(context.Context, *VersionRequest) (*VersionResponse, error)
	Reset(Daemon_ResetServer) error
	Uninstall(Daemon_UninstallServer) error
	Quit(Daemon_QuitServer) error
	Identify(context.Context, *IdentifyRequest) (*IdentifyResponse, error)
	mustEmbedUnimplementedDaemonServer()
}

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

func (UnimplementedDaemonServer) Connect(Daemon_ConnectServer) error {
	return status.Errorf(codes.Unimplemented, "method Connect not implemented")
}
func (UnimplementedDaemonServer) Disconnect(Daemon_DisconnectServer) error {
	return status.Errorf(codes.Unimplemented, "method Disconnect not implemented")
}
func (UnimplementedDaemonServer) Proxy(Daemon_ProxyServer) error {
	return status.Errorf(codes.Unimplemented, "method Proxy not implemented")
}
func (UnimplementedDaemonServer) Leave(Daemon_LeaveServer) error {
	return status.Errorf(codes.Unimplemented, "method Leave not implemented")
}
func (UnimplementedDaemonServer) Sync(Daemon_SyncServer) error {
	return status.Errorf(codes.Unimplemented, "method Sync not implemented")
}
func (UnimplementedDaemonServer) Unsync(Daemon_UnsyncServer) error {
	return status.Errorf(codes.Unimplemented, "method Unsync not implemented")
}
func (UnimplementedDaemonServer) ConnectionList(context.Context, *ConnectionListRequest) (*ConnectionListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConnectionList not implemented")
}
func (UnimplementedDaemonServer) ConnectionUse(context.Context, *ConnectionUseRequest) (*ConnectionUseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConnectionUse not implemented")
}
func (UnimplementedDaemonServer) SshStart(context.Context, *SshStartRequest) (*SshStartResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SshStart not implemented")
}
func (UnimplementedDaemonServer) SshStop(context.Context, *SshStopRequest) (*SshStopResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SshStop not implemented")
}
func (UnimplementedDaemonServer) Route(context.Context, *RouteRequest) (*RouteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Route not implemented")
}
func (UnimplementedDaemonServer) Logs(Daemon_LogsServer) error {
	return status.Errorf(codes.Unimplemented, "method Logs not implemented")
}
func (UnimplementedDaemonServer) Upgrade(context.Context, *UpgradeRequest) (*UpgradeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upgrade not implemented")
}
func (UnimplementedDaemonServer) Status(context.Context, *StatusRequest) (*StatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedDaemonServer) Version(context.Context, *VersionRequest) (*VersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (UnimplementedDaemonServer) Reset(Daemon_ResetServer) error {
	return status.Errorf(codes.Unimplemented, "method Reset not implemented")
}
func (UnimplementedDaemonServer) Uninstall(Daemon_UninstallServer) error {
	return status.Errorf(codes.Unimplemented, "method Uninstall not implemented")
}
func (UnimplementedDaemonServer) Quit(Daemon_QuitServer) error {
	return status.Errorf(codes.Unimplemented, "method Quit not implemented")
}
func (UnimplementedDaemonServer) Identify(context.Context, *IdentifyRequest) (*IdentifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Identify not implemented")
}
func (UnimplementedDaemonServer) mustEmbedUnimplementedDaemonServer() {}

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

func RegisterDaemonServer(s grpc.ServiceRegistrar, srv DaemonServer) {
	s.RegisterService(&Daemon_ServiceDesc, srv)
}

func _Daemon_Connect_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Connect(&daemonConnectServer{stream})
}

type Daemon_ConnectServer interface {
	Send(*ConnectResponse) error
	Recv() (*ConnectRequest, error)
	grpc.ServerStream
}

type daemonConnectServer struct {
	grpc.ServerStream
}

func (x *daemonConnectServer) Send(m *ConnectResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Disconnect_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Disconnect(&daemonDisconnectServer{stream})
}

type Daemon_DisconnectServer interface {
	Send(*DisconnectResponse) error
	Recv() (*DisconnectRequest, error)
	grpc.ServerStream
}

type daemonDisconnectServer struct {
	grpc.ServerStream
}

func (x *daemonDisconnectServer) Send(m *DisconnectResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Proxy_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Proxy(&daemonProxyServer{stream})
}

type Daemon_ProxyServer interface {
	Send(*ProxyResponse) error
	Recv() (*ProxyRequest, error)
	grpc.ServerStream
}

type daemonProxyServer struct {
	grpc.ServerStream
}

func (x *daemonProxyServer) Send(m *ProxyResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Leave_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Leave(&daemonLeaveServer{stream})
}

type Daemon_LeaveServer interface {
	Send(*LeaveResponse) error
	Recv() (*LeaveRequest, error)
	grpc.ServerStream
}

type daemonLeaveServer struct {
	grpc.ServerStream
}

func (x *daemonLeaveServer) Send(m *LeaveResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Sync_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Sync(&daemonSyncServer{stream})
}

type Daemon_SyncServer interface {
	Send(*SyncResponse) error
	Recv() (*SyncRequest, error)
	grpc.ServerStream
}

type daemonSyncServer struct {
	grpc.ServerStream
}

func (x *daemonSyncServer) Send(m *SyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Unsync_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Unsync(&daemonUnsyncServer{stream})
}

type Daemon_UnsyncServer interface {
	Send(*UnsyncResponse) error
	Recv() (*UnsyncRequest, error)
	grpc.ServerStream
}

type daemonUnsyncServer struct {
	grpc.ServerStream
}

func (x *daemonUnsyncServer) Send(m *UnsyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_ConnectionList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectionListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).ConnectionList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_ConnectionList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).ConnectionList(ctx, req.(*ConnectionListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_ConnectionUse_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectionUseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).ConnectionUse(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_ConnectionUse_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).ConnectionUse(ctx, req.(*ConnectionUseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_SshStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SshStartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).SshStart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_SshStart_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).SshStart(ctx, req.(*SshStartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_SshStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SshStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).SshStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_SshStop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).SshStop(ctx, req.(*SshStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_Route_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).Route(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_Route_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).Route(ctx, req.(*RouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_Logs_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Logs(&daemonLogsServer{stream})
}

type Daemon_LogsServer interface {
	Send(*LogResponse) error
	Recv() (*LogRequest, error)
	grpc.ServerStream
}

type daemonLogsServer struct {
	grpc.ServerStream
}

func (x *daemonLogsServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Upgrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpgradeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).Upgrade(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_Upgrade_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).Upgrade(ctx, req.(*UpgradeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_Status_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).Status(ctx, req.(*StatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_Version_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).Version(ctx, req.(*VersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Daemon_Reset_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Reset(&daemonResetServer{stream})
}

type Daemon_ResetServer interface {
	Send(*ResetResponse) error
	Recv() (*ResetRequest, error)
	grpc.ServerStream
}

type daemonResetServer struct {
	grpc.ServerStream
}

func (x *daemonResetServer) Send(m *ResetResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Uninstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Uninstall(&daemonUninstallServer{stream})
}

type Daemon_UninstallServer interface {
	Send(*UninstallResponse) error
	Recv() (*UninstallRequest, error)
	grpc.ServerStream
}

type daemonUninstallServer struct {
	grpc.ServerStream
}

func (x *daemonUninstallServer) Send(m *UninstallResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Quit_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(DaemonServer).Quit(&daemonQuitServer{stream})
}

type Daemon_QuitServer interface {
	Send(*QuitResponse) error
	Recv() (*QuitRequest, error)
	grpc.ServerStream
}

type daemonQuitServer struct {
	grpc.ServerStream
}

func (x *daemonQuitServer) Send(m *QuitResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Daemon_Identify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdentifyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DaemonServer).Identify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Daemon_Identify_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DaemonServer).Identify(ctx, req.(*IdentifyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Daemon_ServiceDesc is the grpc.ServiceDesc for Daemon service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Daemon_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rpc.Daemon",
	HandlerType: (*DaemonServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ConnectionList",
			Handler:    _Daemon_ConnectionList_Handler,
		},
		{
			MethodName: "ConnectionUse",
			Handler:    _Daemon_ConnectionUse_Handler,
		},
		{
			MethodName: "SshStart",
			Handler:    _Daemon_SshStart_Handler,
		},
		{
			MethodName: "SshStop",
			Handler:    _Daemon_SshStop_Handler,
		},
		{
			MethodName: "Route",
			Handler:    _Daemon_Route_Handler,
		},
		{
			MethodName: "Upgrade",
			Handler:    _Daemon_Upgrade_Handler,
		},
		{
			MethodName: "Status",
			Handler:    _Daemon_Status_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _Daemon_Version_Handler,
		},
		{
			MethodName: "Identify",
			Handler:    _Daemon_Identify_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Connect",
			Handler:       _Daemon_Connect_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Disconnect",
			Handler:       _Daemon_Disconnect_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Proxy",
			Handler:       _Daemon_Proxy_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Leave",
			Handler:       _Daemon_Leave_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Sync",
			Handler:       _Daemon_Sync_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Unsync",
			Handler:       _Daemon_Unsync_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Logs",
			Handler:       _Daemon_Logs_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Reset",
			Handler:       _Daemon_Reset_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Uninstall",
			Handler:       _Daemon_Uninstall_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Quit",
			Handler:       _Daemon_Quit_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "daemon.proto",
}
