# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc

from ..clientpb import client_pb2 as clientpb_dot_client__pb2
from ..commonpb import common_pb2 as commonpb_dot_common__pb2
from ..sliverpb import sliver_pb2 as sliverpb_dot_sliver__pb2


class SliverRPCStub(object):
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetVersion = channel.unary_unary(
                '/rpcpb.SliverRPC/GetVersion',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Version.FromString,
                )
        self.GetOperators = channel.unary_unary(
                '/rpcpb.SliverRPC/GetOperators',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Operators.FromString,
                )
        self.GetSessions = channel.unary_unary(
                '/rpcpb.SliverRPC/GetSessions',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Sessions.FromString,
                )
        self.KillSession = channel.unary_unary(
                '/rpcpb.SliverRPC/KillSession',
                request_serializer=sliverpb_dot_sliver__pb2.KillSessionReq.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.UpdateSession = channel.unary_unary(
                '/rpcpb.SliverRPC/UpdateSession',
                request_serializer=clientpb_dot_client__pb2.UpdateSession.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Session.FromString,
                )
        self.GetJobs = channel.unary_unary(
                '/rpcpb.SliverRPC/GetJobs',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Jobs.FromString,
                )
        self.KillJob = channel.unary_unary(
                '/rpcpb.SliverRPC/KillJob',
                request_serializer=clientpb_dot_client__pb2.KillJobReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.KillJob.FromString,
                )
        self.StartMTLSListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartMTLSListener',
                request_serializer=clientpb_dot_client__pb2.MTLSListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.MTLSListener.FromString,
                )
        self.StartWGListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartWGListener',
                request_serializer=clientpb_dot_client__pb2.WGListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.WGListener.FromString,
                )
        self.StartDNSListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartDNSListener',
                request_serializer=clientpb_dot_client__pb2.DNSListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.DNSListener.FromString,
                )
        self.StartHTTPSListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartHTTPSListener',
                request_serializer=clientpb_dot_client__pb2.HTTPListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.HTTPListener.FromString,
                )
        self.StartHTTPListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartHTTPListener',
                request_serializer=clientpb_dot_client__pb2.HTTPListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.HTTPListener.FromString,
                )
        self.StartTCPStagerListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartTCPStagerListener',
                request_serializer=clientpb_dot_client__pb2.StagerListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.StagerListener.FromString,
                )
        self.StartHTTPStagerListener = channel.unary_unary(
                '/rpcpb.SliverRPC/StartHTTPStagerListener',
                request_serializer=clientpb_dot_client__pb2.StagerListenerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.StagerListener.FromString,
                )
        self.Generate = channel.unary_unary(
                '/rpcpb.SliverRPC/Generate',
                request_serializer=clientpb_dot_client__pb2.GenerateReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Generate.FromString,
                )
        self.Regenerate = channel.unary_unary(
                '/rpcpb.SliverRPC/Regenerate',
                request_serializer=clientpb_dot_client__pb2.RegenerateReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Generate.FromString,
                )
        self.ImplantBuilds = channel.unary_unary(
                '/rpcpb.SliverRPC/ImplantBuilds',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.ImplantBuilds.FromString,
                )
        self.DeleteImplantBuild = channel.unary_unary(
                '/rpcpb.SliverRPC/DeleteImplantBuild',
                request_serializer=clientpb_dot_client__pb2.DeleteReq.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.Canaries = channel.unary_unary(
                '/rpcpb.SliverRPC/Canaries',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Canaries.FromString,
                )
        self.GenerateWGClientConfig = channel.unary_unary(
                '/rpcpb.SliverRPC/GenerateWGClientConfig',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.WGClientConfig.FromString,
                )
        self.GenerateUniqueIP = channel.unary_unary(
                '/rpcpb.SliverRPC/GenerateUniqueIP',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.UniqueWGIP.FromString,
                )
        self.ImplantProfiles = channel.unary_unary(
                '/rpcpb.SliverRPC/ImplantProfiles',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.ImplantProfiles.FromString,
                )
        self.DeleteImplantProfile = channel.unary_unary(
                '/rpcpb.SliverRPC/DeleteImplantProfile',
                request_serializer=clientpb_dot_client__pb2.DeleteReq.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.SaveImplantProfile = channel.unary_unary(
                '/rpcpb.SliverRPC/SaveImplantProfile',
                request_serializer=clientpb_dot_client__pb2.ImplantProfile.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.ImplantProfile.FromString,
                )
        self.MsfStage = channel.unary_unary(
                '/rpcpb.SliverRPC/MsfStage',
                request_serializer=clientpb_dot_client__pb2.MsfStagerReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.MsfStager.FromString,
                )
        self.ShellcodeRDI = channel.unary_unary(
                '/rpcpb.SliverRPC/ShellcodeRDI',
                request_serializer=clientpb_dot_client__pb2.ShellcodeRDIReq.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.ShellcodeRDI.FromString,
                )
        self.Websites = channel.unary_unary(
                '/rpcpb.SliverRPC/Websites',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Websites.FromString,
                )
        self.Website = channel.unary_unary(
                '/rpcpb.SliverRPC/Website',
                request_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Website.FromString,
                )
        self.WebsiteRemove = channel.unary_unary(
                '/rpcpb.SliverRPC/WebsiteRemove',
                request_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.WebsiteAddContent = channel.unary_unary(
                '/rpcpb.SliverRPC/WebsiteAddContent',
                request_serializer=clientpb_dot_client__pb2.WebsiteAddContent.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Website.FromString,
                )
        self.WebsiteUpdateContent = channel.unary_unary(
                '/rpcpb.SliverRPC/WebsiteUpdateContent',
                request_serializer=clientpb_dot_client__pb2.WebsiteAddContent.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Website.FromString,
                )
        self.WebsiteRemoveContent = channel.unary_unary(
                '/rpcpb.SliverRPC/WebsiteRemoveContent',
                request_serializer=clientpb_dot_client__pb2.WebsiteRemoveContent.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Website.FromString,
                )
        self.Ping = channel.unary_unary(
                '/rpcpb.SliverRPC/Ping',
                request_serializer=sliverpb_dot_sliver__pb2.Ping.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Ping.FromString,
                )
        self.Ps = channel.unary_unary(
                '/rpcpb.SliverRPC/Ps',
                request_serializer=sliverpb_dot_sliver__pb2.PsReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Ps.FromString,
                )
        self.Terminate = channel.unary_unary(
                '/rpcpb.SliverRPC/Terminate',
                request_serializer=sliverpb_dot_sliver__pb2.TerminateReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Terminate.FromString,
                )
        self.Ifconfig = channel.unary_unary(
                '/rpcpb.SliverRPC/Ifconfig',
                request_serializer=sliverpb_dot_sliver__pb2.IfconfigReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Ifconfig.FromString,
                )
        self.Netstat = channel.unary_unary(
                '/rpcpb.SliverRPC/Netstat',
                request_serializer=sliverpb_dot_sliver__pb2.NetstatReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Netstat.FromString,
                )
        self.Ls = channel.unary_unary(
                '/rpcpb.SliverRPC/Ls',
                request_serializer=sliverpb_dot_sliver__pb2.LsReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Ls.FromString,
                )
        self.Cd = channel.unary_unary(
                '/rpcpb.SliverRPC/Cd',
                request_serializer=sliverpb_dot_sliver__pb2.CdReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Pwd.FromString,
                )
        self.Pwd = channel.unary_unary(
                '/rpcpb.SliverRPC/Pwd',
                request_serializer=sliverpb_dot_sliver__pb2.PwdReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Pwd.FromString,
                )
        self.Rm = channel.unary_unary(
                '/rpcpb.SliverRPC/Rm',
                request_serializer=sliverpb_dot_sliver__pb2.RmReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Rm.FromString,
                )
        self.Mkdir = channel.unary_unary(
                '/rpcpb.SliverRPC/Mkdir',
                request_serializer=sliverpb_dot_sliver__pb2.MkdirReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Mkdir.FromString,
                )
        self.Download = channel.unary_unary(
                '/rpcpb.SliverRPC/Download',
                request_serializer=sliverpb_dot_sliver__pb2.DownloadReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Download.FromString,
                )
        self.Upload = channel.unary_unary(
                '/rpcpb.SliverRPC/Upload',
                request_serializer=sliverpb_dot_sliver__pb2.UploadReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Upload.FromString,
                )
        self.ProcessDump = channel.unary_unary(
                '/rpcpb.SliverRPC/ProcessDump',
                request_serializer=sliverpb_dot_sliver__pb2.ProcessDumpReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.ProcessDump.FromString,
                )
        self.RunAs = channel.unary_unary(
                '/rpcpb.SliverRPC/RunAs',
                request_serializer=sliverpb_dot_sliver__pb2.RunAsReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.RunAs.FromString,
                )
        self.Impersonate = channel.unary_unary(
                '/rpcpb.SliverRPC/Impersonate',
                request_serializer=sliverpb_dot_sliver__pb2.ImpersonateReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Impersonate.FromString,
                )
        self.RevToSelf = channel.unary_unary(
                '/rpcpb.SliverRPC/RevToSelf',
                request_serializer=sliverpb_dot_sliver__pb2.RevToSelfReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.RevToSelf.FromString,
                )
        self.GetSystem = channel.unary_unary(
                '/rpcpb.SliverRPC/GetSystem',
                request_serializer=clientpb_dot_client__pb2.GetSystemReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.GetSystem.FromString,
                )
        self.Task = channel.unary_unary(
                '/rpcpb.SliverRPC/Task',
                request_serializer=sliverpb_dot_sliver__pb2.TaskReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Task.FromString,
                )
        self.Msf = channel.unary_unary(
                '/rpcpb.SliverRPC/Msf',
                request_serializer=clientpb_dot_client__pb2.MSFReq.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.MsfRemote = channel.unary_unary(
                '/rpcpb.SliverRPC/MsfRemote',
                request_serializer=clientpb_dot_client__pb2.MSFRemoteReq.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.ExecuteAssembly = channel.unary_unary(
                '/rpcpb.SliverRPC/ExecuteAssembly',
                request_serializer=sliverpb_dot_sliver__pb2.ExecuteAssemblyReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.ExecuteAssembly.FromString,
                )
        self.Migrate = channel.unary_unary(
                '/rpcpb.SliverRPC/Migrate',
                request_serializer=clientpb_dot_client__pb2.MigrateReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Migrate.FromString,
                )
        self.Execute = channel.unary_unary(
                '/rpcpb.SliverRPC/Execute',
                request_serializer=sliverpb_dot_sliver__pb2.ExecuteReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Execute.FromString,
                )
        self.ExecuteToken = channel.unary_unary(
                '/rpcpb.SliverRPC/ExecuteToken',
                request_serializer=sliverpb_dot_sliver__pb2.ExecuteTokenReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Execute.FromString,
                )
        self.Sideload = channel.unary_unary(
                '/rpcpb.SliverRPC/Sideload',
                request_serializer=sliverpb_dot_sliver__pb2.SideloadReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Sideload.FromString,
                )
        self.SpawnDll = channel.unary_unary(
                '/rpcpb.SliverRPC/SpawnDll',
                request_serializer=sliverpb_dot_sliver__pb2.InvokeSpawnDllReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.SpawnDll.FromString,
                )
        self.Screenshot = channel.unary_unary(
                '/rpcpb.SliverRPC/Screenshot',
                request_serializer=sliverpb_dot_sliver__pb2.ScreenshotReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Screenshot.FromString,
                )
        self.NamedPipes = channel.unary_unary(
                '/rpcpb.SliverRPC/NamedPipes',
                request_serializer=sliverpb_dot_sliver__pb2.NamedPipesReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.NamedPipes.FromString,
                )
        self.TCPListener = channel.unary_unary(
                '/rpcpb.SliverRPC/TCPListener',
                request_serializer=sliverpb_dot_sliver__pb2.TCPPivotReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.TCPPivot.FromString,
                )
        self.ListPivots = channel.unary_unary(
                '/rpcpb.SliverRPC/ListPivots',
                request_serializer=sliverpb_dot_sliver__pb2.PivotListReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.PivotList.FromString,
                )
        self.StartService = channel.unary_unary(
                '/rpcpb.SliverRPC/StartService',
                request_serializer=sliverpb_dot_sliver__pb2.StartServiceReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
                )
        self.StopService = channel.unary_unary(
                '/rpcpb.SliverRPC/StopService',
                request_serializer=sliverpb_dot_sliver__pb2.StopServiceReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
                )
        self.RemoveService = channel.unary_unary(
                '/rpcpb.SliverRPC/RemoveService',
                request_serializer=sliverpb_dot_sliver__pb2.RemoveServiceReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
                )
        self.MakeToken = channel.unary_unary(
                '/rpcpb.SliverRPC/MakeToken',
                request_serializer=sliverpb_dot_sliver__pb2.MakeTokenReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.MakeToken.FromString,
                )
        self.GetEnv = channel.unary_unary(
                '/rpcpb.SliverRPC/GetEnv',
                request_serializer=sliverpb_dot_sliver__pb2.EnvReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.EnvInfo.FromString,
                )
        self.SetEnv = channel.unary_unary(
                '/rpcpb.SliverRPC/SetEnv',
                request_serializer=sliverpb_dot_sliver__pb2.SetEnvReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.SetEnv.FromString,
                )
        self.Backdoor = channel.unary_unary(
                '/rpcpb.SliverRPC/Backdoor',
                request_serializer=sliverpb_dot_sliver__pb2.BackdoorReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Backdoor.FromString,
                )
        self.RegistryRead = channel.unary_unary(
                '/rpcpb.SliverRPC/RegistryRead',
                request_serializer=sliverpb_dot_sliver__pb2.RegistryReadReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.RegistryRead.FromString,
                )
        self.RegistryWrite = channel.unary_unary(
                '/rpcpb.SliverRPC/RegistryWrite',
                request_serializer=sliverpb_dot_sliver__pb2.RegistryWriteReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.RegistryWrite.FromString,
                )
        self.RegistryCreateKey = channel.unary_unary(
                '/rpcpb.SliverRPC/RegistryCreateKey',
                request_serializer=sliverpb_dot_sliver__pb2.RegistryCreateKeyReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.RegistryCreateKey.FromString,
                )
        self.Shell = channel.unary_unary(
                '/rpcpb.SliverRPC/Shell',
                request_serializer=sliverpb_dot_sliver__pb2.ShellReq.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Shell.FromString,
                )
        self.CreateTunnel = channel.unary_unary(
                '/rpcpb.SliverRPC/CreateTunnel',
                request_serializer=sliverpb_dot_sliver__pb2.Tunnel.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.Tunnel.FromString,
                )
        self.CloseTunnel = channel.unary_unary(
                '/rpcpb.SliverRPC/CloseTunnel',
                request_serializer=sliverpb_dot_sliver__pb2.Tunnel.SerializeToString,
                response_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                )
        self.TunnelData = channel.stream_stream(
                '/rpcpb.SliverRPC/TunnelData',
                request_serializer=sliverpb_dot_sliver__pb2.TunnelData.SerializeToString,
                response_deserializer=sliverpb_dot_sliver__pb2.TunnelData.FromString,
                )
        self.Events = channel.unary_stream(
                '/rpcpb.SliverRPC/Events',
                request_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
                response_deserializer=clientpb_dot_client__pb2.Event.FromString,
                )


class SliverRPCServicer(object):
    """Missing associated documentation comment in .proto file."""

    def GetVersion(self, request, context):
        """*** Version ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOperators(self, request, context):
        """*** Operator Commands *** 
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSessions(self, request, context):
        """*** Sessions ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def KillSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetJobs(self, request, context):
        """*** Jobs ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def KillJob(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartMTLSListener(self, request, context):
        """*** Listeners ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartWGListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartDNSListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartHTTPSListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartHTTPListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartTCPStagerListener(self, request, context):
        """*** Stager Listener ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartHTTPStagerListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Generate(self, request, context):
        """*** Implants ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Regenerate(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ImplantBuilds(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteImplantBuild(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Canaries(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GenerateWGClientConfig(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GenerateUniqueIP(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ImplantProfiles(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteImplantProfile(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SaveImplantProfile(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MsfStage(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ShellcodeRDI(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Websites(self, request, context):
        """*** Websites ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Website(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WebsiteRemove(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WebsiteAddContent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WebsiteUpdateContent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WebsiteRemoveContent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ping(self, request, context):
        """*** Session Interactions ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ps(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Terminate(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ifconfig(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Netstat(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ls(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Cd(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Pwd(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Rm(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Mkdir(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Download(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Upload(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ProcessDump(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunAs(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Impersonate(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RevToSelf(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSystem(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Task(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Msf(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MsfRemote(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteAssembly(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Migrate(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Execute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteToken(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Sideload(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SpawnDll(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Screenshot(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NamedPipes(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TCPListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListPivots(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartService(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopService(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveService(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MakeToken(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetEnv(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetEnv(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Backdoor(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegistryRead(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegistryWrite(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegistryCreateKey(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Shell(self, request, context):
        """*** Realtime Commands ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateTunnel(self, request, context):
        """*** Tunnels ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CloseTunnel(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TunnelData(self, request_iterator, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Events(self, request, context):
        """*** Events ***
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_SliverRPCServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetVersion': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVersion,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Version.SerializeToString,
            ),
            'GetOperators': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOperators,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Operators.SerializeToString,
            ),
            'GetSessions': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSessions,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Sessions.SerializeToString,
            ),
            'KillSession': grpc.unary_unary_rpc_method_handler(
                    servicer.KillSession,
                    request_deserializer=sliverpb_dot_sliver__pb2.KillSessionReq.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'UpdateSession': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSession,
                    request_deserializer=clientpb_dot_client__pb2.UpdateSession.FromString,
                    response_serializer=clientpb_dot_client__pb2.Session.SerializeToString,
            ),
            'GetJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetJobs,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Jobs.SerializeToString,
            ),
            'KillJob': grpc.unary_unary_rpc_method_handler(
                    servicer.KillJob,
                    request_deserializer=clientpb_dot_client__pb2.KillJobReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.KillJob.SerializeToString,
            ),
            'StartMTLSListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartMTLSListener,
                    request_deserializer=clientpb_dot_client__pb2.MTLSListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.MTLSListener.SerializeToString,
            ),
            'StartWGListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartWGListener,
                    request_deserializer=clientpb_dot_client__pb2.WGListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.WGListener.SerializeToString,
            ),
            'StartDNSListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartDNSListener,
                    request_deserializer=clientpb_dot_client__pb2.DNSListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.DNSListener.SerializeToString,
            ),
            'StartHTTPSListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartHTTPSListener,
                    request_deserializer=clientpb_dot_client__pb2.HTTPListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.HTTPListener.SerializeToString,
            ),
            'StartHTTPListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartHTTPListener,
                    request_deserializer=clientpb_dot_client__pb2.HTTPListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.HTTPListener.SerializeToString,
            ),
            'StartTCPStagerListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartTCPStagerListener,
                    request_deserializer=clientpb_dot_client__pb2.StagerListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.StagerListener.SerializeToString,
            ),
            'StartHTTPStagerListener': grpc.unary_unary_rpc_method_handler(
                    servicer.StartHTTPStagerListener,
                    request_deserializer=clientpb_dot_client__pb2.StagerListenerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.StagerListener.SerializeToString,
            ),
            'Generate': grpc.unary_unary_rpc_method_handler(
                    servicer.Generate,
                    request_deserializer=clientpb_dot_client__pb2.GenerateReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.Generate.SerializeToString,
            ),
            'Regenerate': grpc.unary_unary_rpc_method_handler(
                    servicer.Regenerate,
                    request_deserializer=clientpb_dot_client__pb2.RegenerateReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.Generate.SerializeToString,
            ),
            'ImplantBuilds': grpc.unary_unary_rpc_method_handler(
                    servicer.ImplantBuilds,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.ImplantBuilds.SerializeToString,
            ),
            'DeleteImplantBuild': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteImplantBuild,
                    request_deserializer=clientpb_dot_client__pb2.DeleteReq.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'Canaries': grpc.unary_unary_rpc_method_handler(
                    servicer.Canaries,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Canaries.SerializeToString,
            ),
            'GenerateWGClientConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateWGClientConfig,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.WGClientConfig.SerializeToString,
            ),
            'GenerateUniqueIP': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateUniqueIP,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.UniqueWGIP.SerializeToString,
            ),
            'ImplantProfiles': grpc.unary_unary_rpc_method_handler(
                    servicer.ImplantProfiles,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.ImplantProfiles.SerializeToString,
            ),
            'DeleteImplantProfile': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteImplantProfile,
                    request_deserializer=clientpb_dot_client__pb2.DeleteReq.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'SaveImplantProfile': grpc.unary_unary_rpc_method_handler(
                    servicer.SaveImplantProfile,
                    request_deserializer=clientpb_dot_client__pb2.ImplantProfile.FromString,
                    response_serializer=clientpb_dot_client__pb2.ImplantProfile.SerializeToString,
            ),
            'MsfStage': grpc.unary_unary_rpc_method_handler(
                    servicer.MsfStage,
                    request_deserializer=clientpb_dot_client__pb2.MsfStagerReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.MsfStager.SerializeToString,
            ),
            'ShellcodeRDI': grpc.unary_unary_rpc_method_handler(
                    servicer.ShellcodeRDI,
                    request_deserializer=clientpb_dot_client__pb2.ShellcodeRDIReq.FromString,
                    response_serializer=clientpb_dot_client__pb2.ShellcodeRDI.SerializeToString,
            ),
            'Websites': grpc.unary_unary_rpc_method_handler(
                    servicer.Websites,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Websites.SerializeToString,
            ),
            'Website': grpc.unary_unary_rpc_method_handler(
                    servicer.Website,
                    request_deserializer=clientpb_dot_client__pb2.Website.FromString,
                    response_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
            ),
            'WebsiteRemove': grpc.unary_unary_rpc_method_handler(
                    servicer.WebsiteRemove,
                    request_deserializer=clientpb_dot_client__pb2.Website.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'WebsiteAddContent': grpc.unary_unary_rpc_method_handler(
                    servicer.WebsiteAddContent,
                    request_deserializer=clientpb_dot_client__pb2.WebsiteAddContent.FromString,
                    response_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
            ),
            'WebsiteUpdateContent': grpc.unary_unary_rpc_method_handler(
                    servicer.WebsiteUpdateContent,
                    request_deserializer=clientpb_dot_client__pb2.WebsiteAddContent.FromString,
                    response_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
            ),
            'WebsiteRemoveContent': grpc.unary_unary_rpc_method_handler(
                    servicer.WebsiteRemoveContent,
                    request_deserializer=clientpb_dot_client__pb2.WebsiteRemoveContent.FromString,
                    response_serializer=clientpb_dot_client__pb2.Website.SerializeToString,
            ),
            'Ping': grpc.unary_unary_rpc_method_handler(
                    servicer.Ping,
                    request_deserializer=sliverpb_dot_sliver__pb2.Ping.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Ping.SerializeToString,
            ),
            'Ps': grpc.unary_unary_rpc_method_handler(
                    servicer.Ps,
                    request_deserializer=sliverpb_dot_sliver__pb2.PsReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Ps.SerializeToString,
            ),
            'Terminate': grpc.unary_unary_rpc_method_handler(
                    servicer.Terminate,
                    request_deserializer=sliverpb_dot_sliver__pb2.TerminateReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Terminate.SerializeToString,
            ),
            'Ifconfig': grpc.unary_unary_rpc_method_handler(
                    servicer.Ifconfig,
                    request_deserializer=sliverpb_dot_sliver__pb2.IfconfigReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Ifconfig.SerializeToString,
            ),
            'Netstat': grpc.unary_unary_rpc_method_handler(
                    servicer.Netstat,
                    request_deserializer=sliverpb_dot_sliver__pb2.NetstatReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Netstat.SerializeToString,
            ),
            'Ls': grpc.unary_unary_rpc_method_handler(
                    servicer.Ls,
                    request_deserializer=sliverpb_dot_sliver__pb2.LsReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Ls.SerializeToString,
            ),
            'Cd': grpc.unary_unary_rpc_method_handler(
                    servicer.Cd,
                    request_deserializer=sliverpb_dot_sliver__pb2.CdReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Pwd.SerializeToString,
            ),
            'Pwd': grpc.unary_unary_rpc_method_handler(
                    servicer.Pwd,
                    request_deserializer=sliverpb_dot_sliver__pb2.PwdReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Pwd.SerializeToString,
            ),
            'Rm': grpc.unary_unary_rpc_method_handler(
                    servicer.Rm,
                    request_deserializer=sliverpb_dot_sliver__pb2.RmReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Rm.SerializeToString,
            ),
            'Mkdir': grpc.unary_unary_rpc_method_handler(
                    servicer.Mkdir,
                    request_deserializer=sliverpb_dot_sliver__pb2.MkdirReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Mkdir.SerializeToString,
            ),
            'Download': grpc.unary_unary_rpc_method_handler(
                    servicer.Download,
                    request_deserializer=sliverpb_dot_sliver__pb2.DownloadReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Download.SerializeToString,
            ),
            'Upload': grpc.unary_unary_rpc_method_handler(
                    servicer.Upload,
                    request_deserializer=sliverpb_dot_sliver__pb2.UploadReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Upload.SerializeToString,
            ),
            'ProcessDump': grpc.unary_unary_rpc_method_handler(
                    servicer.ProcessDump,
                    request_deserializer=sliverpb_dot_sliver__pb2.ProcessDumpReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.ProcessDump.SerializeToString,
            ),
            'RunAs': grpc.unary_unary_rpc_method_handler(
                    servicer.RunAs,
                    request_deserializer=sliverpb_dot_sliver__pb2.RunAsReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.RunAs.SerializeToString,
            ),
            'Impersonate': grpc.unary_unary_rpc_method_handler(
                    servicer.Impersonate,
                    request_deserializer=sliverpb_dot_sliver__pb2.ImpersonateReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Impersonate.SerializeToString,
            ),
            'RevToSelf': grpc.unary_unary_rpc_method_handler(
                    servicer.RevToSelf,
                    request_deserializer=sliverpb_dot_sliver__pb2.RevToSelfReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.RevToSelf.SerializeToString,
            ),
            'GetSystem': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSystem,
                    request_deserializer=clientpb_dot_client__pb2.GetSystemReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.GetSystem.SerializeToString,
            ),
            'Task': grpc.unary_unary_rpc_method_handler(
                    servicer.Task,
                    request_deserializer=sliverpb_dot_sliver__pb2.TaskReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Task.SerializeToString,
            ),
            'Msf': grpc.unary_unary_rpc_method_handler(
                    servicer.Msf,
                    request_deserializer=clientpb_dot_client__pb2.MSFReq.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'MsfRemote': grpc.unary_unary_rpc_method_handler(
                    servicer.MsfRemote,
                    request_deserializer=clientpb_dot_client__pb2.MSFRemoteReq.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'ExecuteAssembly': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteAssembly,
                    request_deserializer=sliverpb_dot_sliver__pb2.ExecuteAssemblyReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.ExecuteAssembly.SerializeToString,
            ),
            'Migrate': grpc.unary_unary_rpc_method_handler(
                    servicer.Migrate,
                    request_deserializer=clientpb_dot_client__pb2.MigrateReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Migrate.SerializeToString,
            ),
            'Execute': grpc.unary_unary_rpc_method_handler(
                    servicer.Execute,
                    request_deserializer=sliverpb_dot_sliver__pb2.ExecuteReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Execute.SerializeToString,
            ),
            'ExecuteToken': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteToken,
                    request_deserializer=sliverpb_dot_sliver__pb2.ExecuteTokenReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Execute.SerializeToString,
            ),
            'Sideload': grpc.unary_unary_rpc_method_handler(
                    servicer.Sideload,
                    request_deserializer=sliverpb_dot_sliver__pb2.SideloadReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Sideload.SerializeToString,
            ),
            'SpawnDll': grpc.unary_unary_rpc_method_handler(
                    servicer.SpawnDll,
                    request_deserializer=sliverpb_dot_sliver__pb2.InvokeSpawnDllReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.SpawnDll.SerializeToString,
            ),
            'Screenshot': grpc.unary_unary_rpc_method_handler(
                    servicer.Screenshot,
                    request_deserializer=sliverpb_dot_sliver__pb2.ScreenshotReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Screenshot.SerializeToString,
            ),
            'NamedPipes': grpc.unary_unary_rpc_method_handler(
                    servicer.NamedPipes,
                    request_deserializer=sliverpb_dot_sliver__pb2.NamedPipesReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.NamedPipes.SerializeToString,
            ),
            'TCPListener': grpc.unary_unary_rpc_method_handler(
                    servicer.TCPListener,
                    request_deserializer=sliverpb_dot_sliver__pb2.TCPPivotReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.TCPPivot.SerializeToString,
            ),
            'ListPivots': grpc.unary_unary_rpc_method_handler(
                    servicer.ListPivots,
                    request_deserializer=sliverpb_dot_sliver__pb2.PivotListReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.PivotList.SerializeToString,
            ),
            'StartService': grpc.unary_unary_rpc_method_handler(
                    servicer.StartService,
                    request_deserializer=sliverpb_dot_sliver__pb2.StartServiceReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.ServiceInfo.SerializeToString,
            ),
            'StopService': grpc.unary_unary_rpc_method_handler(
                    servicer.StopService,
                    request_deserializer=sliverpb_dot_sliver__pb2.StopServiceReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.ServiceInfo.SerializeToString,
            ),
            'RemoveService': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveService,
                    request_deserializer=sliverpb_dot_sliver__pb2.RemoveServiceReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.ServiceInfo.SerializeToString,
            ),
            'MakeToken': grpc.unary_unary_rpc_method_handler(
                    servicer.MakeToken,
                    request_deserializer=sliverpb_dot_sliver__pb2.MakeTokenReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.MakeToken.SerializeToString,
            ),
            'GetEnv': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEnv,
                    request_deserializer=sliverpb_dot_sliver__pb2.EnvReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.EnvInfo.SerializeToString,
            ),
            'SetEnv': grpc.unary_unary_rpc_method_handler(
                    servicer.SetEnv,
                    request_deserializer=sliverpb_dot_sliver__pb2.SetEnvReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.SetEnv.SerializeToString,
            ),
            'Backdoor': grpc.unary_unary_rpc_method_handler(
                    servicer.Backdoor,
                    request_deserializer=sliverpb_dot_sliver__pb2.BackdoorReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Backdoor.SerializeToString,
            ),
            'RegistryRead': grpc.unary_unary_rpc_method_handler(
                    servicer.RegistryRead,
                    request_deserializer=sliverpb_dot_sliver__pb2.RegistryReadReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.RegistryRead.SerializeToString,
            ),
            'RegistryWrite': grpc.unary_unary_rpc_method_handler(
                    servicer.RegistryWrite,
                    request_deserializer=sliverpb_dot_sliver__pb2.RegistryWriteReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.RegistryWrite.SerializeToString,
            ),
            'RegistryCreateKey': grpc.unary_unary_rpc_method_handler(
                    servicer.RegistryCreateKey,
                    request_deserializer=sliverpb_dot_sliver__pb2.RegistryCreateKeyReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.RegistryCreateKey.SerializeToString,
            ),
            'Shell': grpc.unary_unary_rpc_method_handler(
                    servicer.Shell,
                    request_deserializer=sliverpb_dot_sliver__pb2.ShellReq.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Shell.SerializeToString,
            ),
            'CreateTunnel': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateTunnel,
                    request_deserializer=sliverpb_dot_sliver__pb2.Tunnel.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.Tunnel.SerializeToString,
            ),
            'CloseTunnel': grpc.unary_unary_rpc_method_handler(
                    servicer.CloseTunnel,
                    request_deserializer=sliverpb_dot_sliver__pb2.Tunnel.FromString,
                    response_serializer=commonpb_dot_common__pb2.Empty.SerializeToString,
            ),
            'TunnelData': grpc.stream_stream_rpc_method_handler(
                    servicer.TunnelData,
                    request_deserializer=sliverpb_dot_sliver__pb2.TunnelData.FromString,
                    response_serializer=sliverpb_dot_sliver__pb2.TunnelData.SerializeToString,
            ),
            'Events': grpc.unary_stream_rpc_method_handler(
                    servicer.Events,
                    request_deserializer=commonpb_dot_common__pb2.Empty.FromString,
                    response_serializer=clientpb_dot_client__pb2.Event.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'rpcpb.SliverRPC', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class SliverRPC(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def GetVersion(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetVersion',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Version.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetOperators(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetOperators',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Operators.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSessions(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetSessions',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Sessions.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def KillSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/KillSession',
            sliverpb_dot_sliver__pb2.KillSessionReq.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateSession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/UpdateSession',
            clientpb_dot_client__pb2.UpdateSession.SerializeToString,
            clientpb_dot_client__pb2.Session.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetJobs(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetJobs',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Jobs.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def KillJob(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/KillJob',
            clientpb_dot_client__pb2.KillJobReq.SerializeToString,
            clientpb_dot_client__pb2.KillJob.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartMTLSListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartMTLSListener',
            clientpb_dot_client__pb2.MTLSListenerReq.SerializeToString,
            clientpb_dot_client__pb2.MTLSListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartWGListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartWGListener',
            clientpb_dot_client__pb2.WGListenerReq.SerializeToString,
            clientpb_dot_client__pb2.WGListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartDNSListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartDNSListener',
            clientpb_dot_client__pb2.DNSListenerReq.SerializeToString,
            clientpb_dot_client__pb2.DNSListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartHTTPSListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartHTTPSListener',
            clientpb_dot_client__pb2.HTTPListenerReq.SerializeToString,
            clientpb_dot_client__pb2.HTTPListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartHTTPListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartHTTPListener',
            clientpb_dot_client__pb2.HTTPListenerReq.SerializeToString,
            clientpb_dot_client__pb2.HTTPListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartTCPStagerListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartTCPStagerListener',
            clientpb_dot_client__pb2.StagerListenerReq.SerializeToString,
            clientpb_dot_client__pb2.StagerListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartHTTPStagerListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartHTTPStagerListener',
            clientpb_dot_client__pb2.StagerListenerReq.SerializeToString,
            clientpb_dot_client__pb2.StagerListener.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Generate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Generate',
            clientpb_dot_client__pb2.GenerateReq.SerializeToString,
            clientpb_dot_client__pb2.Generate.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Regenerate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Regenerate',
            clientpb_dot_client__pb2.RegenerateReq.SerializeToString,
            clientpb_dot_client__pb2.Generate.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ImplantBuilds(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ImplantBuilds',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.ImplantBuilds.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteImplantBuild(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/DeleteImplantBuild',
            clientpb_dot_client__pb2.DeleteReq.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Canaries(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Canaries',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Canaries.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenerateWGClientConfig(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GenerateWGClientConfig',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.WGClientConfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenerateUniqueIP(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GenerateUniqueIP',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.UniqueWGIP.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ImplantProfiles(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ImplantProfiles',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.ImplantProfiles.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteImplantProfile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/DeleteImplantProfile',
            clientpb_dot_client__pb2.DeleteReq.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SaveImplantProfile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/SaveImplantProfile',
            clientpb_dot_client__pb2.ImplantProfile.SerializeToString,
            clientpb_dot_client__pb2.ImplantProfile.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MsfStage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/MsfStage',
            clientpb_dot_client__pb2.MsfStagerReq.SerializeToString,
            clientpb_dot_client__pb2.MsfStager.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ShellcodeRDI(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ShellcodeRDI',
            clientpb_dot_client__pb2.ShellcodeRDIReq.SerializeToString,
            clientpb_dot_client__pb2.ShellcodeRDI.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Websites(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Websites',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Websites.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Website(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Website',
            clientpb_dot_client__pb2.Website.SerializeToString,
            clientpb_dot_client__pb2.Website.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WebsiteRemove(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/WebsiteRemove',
            clientpb_dot_client__pb2.Website.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WebsiteAddContent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/WebsiteAddContent',
            clientpb_dot_client__pb2.WebsiteAddContent.SerializeToString,
            clientpb_dot_client__pb2.Website.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WebsiteUpdateContent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/WebsiteUpdateContent',
            clientpb_dot_client__pb2.WebsiteAddContent.SerializeToString,
            clientpb_dot_client__pb2.Website.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def WebsiteRemoveContent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/WebsiteRemoveContent',
            clientpb_dot_client__pb2.WebsiteRemoveContent.SerializeToString,
            clientpb_dot_client__pb2.Website.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Ping(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Ping',
            sliverpb_dot_sliver__pb2.Ping.SerializeToString,
            sliverpb_dot_sliver__pb2.Ping.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Ps(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Ps',
            sliverpb_dot_sliver__pb2.PsReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Ps.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Terminate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Terminate',
            sliverpb_dot_sliver__pb2.TerminateReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Terminate.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Ifconfig(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Ifconfig',
            sliverpb_dot_sliver__pb2.IfconfigReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Ifconfig.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Netstat(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Netstat',
            sliverpb_dot_sliver__pb2.NetstatReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Netstat.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Ls(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Ls',
            sliverpb_dot_sliver__pb2.LsReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Ls.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Cd(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Cd',
            sliverpb_dot_sliver__pb2.CdReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Pwd.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Pwd(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Pwd',
            sliverpb_dot_sliver__pb2.PwdReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Pwd.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Rm(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Rm',
            sliverpb_dot_sliver__pb2.RmReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Rm.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Mkdir(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Mkdir',
            sliverpb_dot_sliver__pb2.MkdirReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Mkdir.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Download(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Download',
            sliverpb_dot_sliver__pb2.DownloadReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Download.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Upload(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Upload',
            sliverpb_dot_sliver__pb2.UploadReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Upload.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ProcessDump(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ProcessDump',
            sliverpb_dot_sliver__pb2.ProcessDumpReq.SerializeToString,
            sliverpb_dot_sliver__pb2.ProcessDump.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RunAs(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RunAs',
            sliverpb_dot_sliver__pb2.RunAsReq.SerializeToString,
            sliverpb_dot_sliver__pb2.RunAs.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Impersonate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Impersonate',
            sliverpb_dot_sliver__pb2.ImpersonateReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Impersonate.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RevToSelf(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RevToSelf',
            sliverpb_dot_sliver__pb2.RevToSelfReq.SerializeToString,
            sliverpb_dot_sliver__pb2.RevToSelf.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetSystem(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetSystem',
            clientpb_dot_client__pb2.GetSystemReq.SerializeToString,
            sliverpb_dot_sliver__pb2.GetSystem.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Task(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Task',
            sliverpb_dot_sliver__pb2.TaskReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Task.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Msf(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Msf',
            clientpb_dot_client__pb2.MSFReq.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MsfRemote(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/MsfRemote',
            clientpb_dot_client__pb2.MSFRemoteReq.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ExecuteAssembly(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ExecuteAssembly',
            sliverpb_dot_sliver__pb2.ExecuteAssemblyReq.SerializeToString,
            sliverpb_dot_sliver__pb2.ExecuteAssembly.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Migrate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Migrate',
            clientpb_dot_client__pb2.MigrateReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Migrate.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Execute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Execute',
            sliverpb_dot_sliver__pb2.ExecuteReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Execute.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ExecuteToken(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ExecuteToken',
            sliverpb_dot_sliver__pb2.ExecuteTokenReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Execute.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Sideload(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Sideload',
            sliverpb_dot_sliver__pb2.SideloadReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Sideload.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SpawnDll(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/SpawnDll',
            sliverpb_dot_sliver__pb2.InvokeSpawnDllReq.SerializeToString,
            sliverpb_dot_sliver__pb2.SpawnDll.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Screenshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Screenshot',
            sliverpb_dot_sliver__pb2.ScreenshotReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Screenshot.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NamedPipes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/NamedPipes',
            sliverpb_dot_sliver__pb2.NamedPipesReq.SerializeToString,
            sliverpb_dot_sliver__pb2.NamedPipes.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TCPListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/TCPListener',
            sliverpb_dot_sliver__pb2.TCPPivotReq.SerializeToString,
            sliverpb_dot_sliver__pb2.TCPPivot.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListPivots(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/ListPivots',
            sliverpb_dot_sliver__pb2.PivotListReq.SerializeToString,
            sliverpb_dot_sliver__pb2.PivotList.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StartService(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StartService',
            sliverpb_dot_sliver__pb2.StartServiceReq.SerializeToString,
            sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def StopService(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/StopService',
            sliverpb_dot_sliver__pb2.StopServiceReq.SerializeToString,
            sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RemoveService(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RemoveService',
            sliverpb_dot_sliver__pb2.RemoveServiceReq.SerializeToString,
            sliverpb_dot_sliver__pb2.ServiceInfo.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MakeToken(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/MakeToken',
            sliverpb_dot_sliver__pb2.MakeTokenReq.SerializeToString,
            sliverpb_dot_sliver__pb2.MakeToken.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetEnv(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/GetEnv',
            sliverpb_dot_sliver__pb2.EnvReq.SerializeToString,
            sliverpb_dot_sliver__pb2.EnvInfo.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SetEnv(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/SetEnv',
            sliverpb_dot_sliver__pb2.SetEnvReq.SerializeToString,
            sliverpb_dot_sliver__pb2.SetEnv.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Backdoor(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Backdoor',
            sliverpb_dot_sliver__pb2.BackdoorReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Backdoor.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegistryRead(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RegistryRead',
            sliverpb_dot_sliver__pb2.RegistryReadReq.SerializeToString,
            sliverpb_dot_sliver__pb2.RegistryRead.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegistryWrite(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RegistryWrite',
            sliverpb_dot_sliver__pb2.RegistryWriteReq.SerializeToString,
            sliverpb_dot_sliver__pb2.RegistryWrite.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegistryCreateKey(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/RegistryCreateKey',
            sliverpb_dot_sliver__pb2.RegistryCreateKeyReq.SerializeToString,
            sliverpb_dot_sliver__pb2.RegistryCreateKey.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Shell(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/Shell',
            sliverpb_dot_sliver__pb2.ShellReq.SerializeToString,
            sliverpb_dot_sliver__pb2.Shell.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CreateTunnel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/CreateTunnel',
            sliverpb_dot_sliver__pb2.Tunnel.SerializeToString,
            sliverpb_dot_sliver__pb2.Tunnel.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CloseTunnel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/rpcpb.SliverRPC/CloseTunnel',
            sliverpb_dot_sliver__pb2.Tunnel.SerializeToString,
            commonpb_dot_common__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TunnelData(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(request_iterator, target, '/rpcpb.SliverRPC/TunnelData',
            sliverpb_dot_sliver__pb2.TunnelData.SerializeToString,
            sliverpb_dot_sliver__pb2.TunnelData.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Events(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/rpcpb.SliverRPC/Events',
            commonpb_dot_common__pb2.Empty.SerializeToString,
            clientpb_dot_client__pb2.Event.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
