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

package rpcpb

import (
	context "context"
	clientpb "github.com/bishopfox/sliver/protobuf/clientpb"
	commonpb "github.com/bishopfox/sliver/protobuf/commonpb"
	sliverpb "github.com/bishopfox/sliver/protobuf/sliverpb"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	SliverRPC_GetVersion_FullMethodName                       = "/rpcpb.SliverRPC/GetVersion"
	SliverRPC_ClientLog_FullMethodName                        = "/rpcpb.SliverRPC/ClientLog"
	SliverRPC_GetOperators_FullMethodName                     = "/rpcpb.SliverRPC/GetOperators"
	SliverRPC_Kill_FullMethodName                             = "/rpcpb.SliverRPC/Kill"
	SliverRPC_Reconfigure_FullMethodName                      = "/rpcpb.SliverRPC/Reconfigure"
	SliverRPC_Rename_FullMethodName                           = "/rpcpb.SliverRPC/Rename"
	SliverRPC_GetSessions_FullMethodName                      = "/rpcpb.SliverRPC/GetSessions"
	SliverRPC_MonitorStart_FullMethodName                     = "/rpcpb.SliverRPC/MonitorStart"
	SliverRPC_MonitorStop_FullMethodName                      = "/rpcpb.SliverRPC/MonitorStop"
	SliverRPC_MonitorListConfig_FullMethodName                = "/rpcpb.SliverRPC/MonitorListConfig"
	SliverRPC_MonitorAddConfig_FullMethodName                 = "/rpcpb.SliverRPC/MonitorAddConfig"
	SliverRPC_MonitorDelConfig_FullMethodName                 = "/rpcpb.SliverRPC/MonitorDelConfig"
	SliverRPC_StartMTLSListener_FullMethodName                = "/rpcpb.SliverRPC/StartMTLSListener"
	SliverRPC_StartWGListener_FullMethodName                  = "/rpcpb.SliverRPC/StartWGListener"
	SliverRPC_StartDNSListener_FullMethodName                 = "/rpcpb.SliverRPC/StartDNSListener"
	SliverRPC_StartHTTPSListener_FullMethodName               = "/rpcpb.SliverRPC/StartHTTPSListener"
	SliverRPC_StartHTTPListener_FullMethodName                = "/rpcpb.SliverRPC/StartHTTPListener"
	SliverRPC_GetBeacons_FullMethodName                       = "/rpcpb.SliverRPC/GetBeacons"
	SliverRPC_GetBeacon_FullMethodName                        = "/rpcpb.SliverRPC/GetBeacon"
	SliverRPC_RmBeacon_FullMethodName                         = "/rpcpb.SliverRPC/RmBeacon"
	SliverRPC_GetBeaconTasks_FullMethodName                   = "/rpcpb.SliverRPC/GetBeaconTasks"
	SliverRPC_GetBeaconTaskContent_FullMethodName             = "/rpcpb.SliverRPC/GetBeaconTaskContent"
	SliverRPC_CancelBeaconTask_FullMethodName                 = "/rpcpb.SliverRPC/CancelBeaconTask"
	SliverRPC_UpdateBeaconIntegrityInformation_FullMethodName = "/rpcpb.SliverRPC/UpdateBeaconIntegrityInformation"
	SliverRPC_GetJobs_FullMethodName                          = "/rpcpb.SliverRPC/GetJobs"
	SliverRPC_KillJob_FullMethodName                          = "/rpcpb.SliverRPC/KillJob"
	SliverRPC_RestartJobs_FullMethodName                      = "/rpcpb.SliverRPC/RestartJobs"
	SliverRPC_StartTCPStagerListener_FullMethodName           = "/rpcpb.SliverRPC/StartTCPStagerListener"
	SliverRPC_LootAdd_FullMethodName                          = "/rpcpb.SliverRPC/LootAdd"
	SliverRPC_LootRm_FullMethodName                           = "/rpcpb.SliverRPC/LootRm"
	SliverRPC_LootUpdate_FullMethodName                       = "/rpcpb.SliverRPC/LootUpdate"
	SliverRPC_LootContent_FullMethodName                      = "/rpcpb.SliverRPC/LootContent"
	SliverRPC_LootAll_FullMethodName                          = "/rpcpb.SliverRPC/LootAll"
	SliverRPC_Creds_FullMethodName                            = "/rpcpb.SliverRPC/Creds"
	SliverRPC_CredsAdd_FullMethodName                         = "/rpcpb.SliverRPC/CredsAdd"
	SliverRPC_CredsRm_FullMethodName                          = "/rpcpb.SliverRPC/CredsRm"
	SliverRPC_CredsUpdate_FullMethodName                      = "/rpcpb.SliverRPC/CredsUpdate"
	SliverRPC_GetCredByID_FullMethodName                      = "/rpcpb.SliverRPC/GetCredByID"
	SliverRPC_GetCredsByHashType_FullMethodName               = "/rpcpb.SliverRPC/GetCredsByHashType"
	SliverRPC_GetPlaintextCredsByHashType_FullMethodName      = "/rpcpb.SliverRPC/GetPlaintextCredsByHashType"
	SliverRPC_CredsSniffHashType_FullMethodName               = "/rpcpb.SliverRPC/CredsSniffHashType"
	SliverRPC_Hosts_FullMethodName                            = "/rpcpb.SliverRPC/Hosts"
	SliverRPC_Host_FullMethodName                             = "/rpcpb.SliverRPC/Host"
	SliverRPC_HostRm_FullMethodName                           = "/rpcpb.SliverRPC/HostRm"
	SliverRPC_HostIOCRm_FullMethodName                        = "/rpcpb.SliverRPC/HostIOCRm"
	SliverRPC_Generate_FullMethodName                         = "/rpcpb.SliverRPC/Generate"
	SliverRPC_GenerateExternal_FullMethodName                 = "/rpcpb.SliverRPC/GenerateExternal"
	SliverRPC_GenerateExternalSaveBuild_FullMethodName        = "/rpcpb.SliverRPC/GenerateExternalSaveBuild"
	SliverRPC_GenerateExternalGetBuildConfig_FullMethodName   = "/rpcpb.SliverRPC/GenerateExternalGetBuildConfig"
	SliverRPC_GenerateStage_FullMethodName                    = "/rpcpb.SliverRPC/GenerateStage"
	SliverRPC_StageImplantBuild_FullMethodName                = "/rpcpb.SliverRPC/StageImplantBuild"
	SliverRPC_GetHTTPC2Profiles_FullMethodName                = "/rpcpb.SliverRPC/GetHTTPC2Profiles"
	SliverRPC_GetHTTPC2ProfileByName_FullMethodName           = "/rpcpb.SliverRPC/GetHTTPC2ProfileByName"
	SliverRPC_SaveHTTPC2Profile_FullMethodName                = "/rpcpb.SliverRPC/SaveHTTPC2Profile"
	SliverRPC_BuilderRegister_FullMethodName                  = "/rpcpb.SliverRPC/BuilderRegister"
	SliverRPC_BuilderTrigger_FullMethodName                   = "/rpcpb.SliverRPC/BuilderTrigger"
	SliverRPC_Builders_FullMethodName                         = "/rpcpb.SliverRPC/Builders"
	SliverRPC_GetCertificateInfo_FullMethodName               = "/rpcpb.SliverRPC/GetCertificateInfo"
	SliverRPC_CrackstationRegister_FullMethodName             = "/rpcpb.SliverRPC/CrackstationRegister"
	SliverRPC_CrackstationTrigger_FullMethodName              = "/rpcpb.SliverRPC/CrackstationTrigger"
	SliverRPC_CrackstationBenchmark_FullMethodName            = "/rpcpb.SliverRPC/CrackstationBenchmark"
	SliverRPC_Crackstations_FullMethodName                    = "/rpcpb.SliverRPC/Crackstations"
	SliverRPC_CrackTaskByID_FullMethodName                    = "/rpcpb.SliverRPC/CrackTaskByID"
	SliverRPC_CrackTaskUpdate_FullMethodName                  = "/rpcpb.SliverRPC/CrackTaskUpdate"
	SliverRPC_CrackFilesList_FullMethodName                   = "/rpcpb.SliverRPC/CrackFilesList"
	SliverRPC_CrackFileCreate_FullMethodName                  = "/rpcpb.SliverRPC/CrackFileCreate"
	SliverRPC_CrackFileChunkUpload_FullMethodName             = "/rpcpb.SliverRPC/CrackFileChunkUpload"
	SliverRPC_CrackFileChunkDownload_FullMethodName           = "/rpcpb.SliverRPC/CrackFileChunkDownload"
	SliverRPC_CrackFileComplete_FullMethodName                = "/rpcpb.SliverRPC/CrackFileComplete"
	SliverRPC_CrackFileDelete_FullMethodName                  = "/rpcpb.SliverRPC/CrackFileDelete"
	SliverRPC_Regenerate_FullMethodName                       = "/rpcpb.SliverRPC/Regenerate"
	SliverRPC_ImplantBuilds_FullMethodName                    = "/rpcpb.SliverRPC/ImplantBuilds"
	SliverRPC_DeleteImplantBuild_FullMethodName               = "/rpcpb.SliverRPC/DeleteImplantBuild"
	SliverRPC_Canaries_FullMethodName                         = "/rpcpb.SliverRPC/Canaries"
	SliverRPC_GenerateWGClientConfig_FullMethodName           = "/rpcpb.SliverRPC/GenerateWGClientConfig"
	SliverRPC_GenerateUniqueIP_FullMethodName                 = "/rpcpb.SliverRPC/GenerateUniqueIP"
	SliverRPC_ImplantProfiles_FullMethodName                  = "/rpcpb.SliverRPC/ImplantProfiles"
	SliverRPC_DeleteImplantProfile_FullMethodName             = "/rpcpb.SliverRPC/DeleteImplantProfile"
	SliverRPC_SaveImplantProfile_FullMethodName               = "/rpcpb.SliverRPC/SaveImplantProfile"
	SliverRPC_ShellcodeRDI_FullMethodName                     = "/rpcpb.SliverRPC/ShellcodeRDI"
	SliverRPC_GetCompiler_FullMethodName                      = "/rpcpb.SliverRPC/GetCompiler"
	SliverRPC_ShellcodeEncoder_FullMethodName                 = "/rpcpb.SliverRPC/ShellcodeEncoder"
	SliverRPC_ShellcodeEncoderMap_FullMethodName              = "/rpcpb.SliverRPC/ShellcodeEncoderMap"
	SliverRPC_TrafficEncoderMap_FullMethodName                = "/rpcpb.SliverRPC/TrafficEncoderMap"
	SliverRPC_TrafficEncoderAdd_FullMethodName                = "/rpcpb.SliverRPC/TrafficEncoderAdd"
	SliverRPC_TrafficEncoderRm_FullMethodName                 = "/rpcpb.SliverRPC/TrafficEncoderRm"
	SliverRPC_Websites_FullMethodName                         = "/rpcpb.SliverRPC/Websites"
	SliverRPC_Website_FullMethodName                          = "/rpcpb.SliverRPC/Website"
	SliverRPC_WebsiteRemove_FullMethodName                    = "/rpcpb.SliverRPC/WebsiteRemove"
	SliverRPC_WebsiteAddContent_FullMethodName                = "/rpcpb.SliverRPC/WebsiteAddContent"
	SliverRPC_WebsiteUpdateContent_FullMethodName             = "/rpcpb.SliverRPC/WebsiteUpdateContent"
	SliverRPC_WebsiteRemoveContent_FullMethodName             = "/rpcpb.SliverRPC/WebsiteRemoveContent"
	SliverRPC_Ping_FullMethodName                             = "/rpcpb.SliverRPC/Ping"
	SliverRPC_Ps_FullMethodName                               = "/rpcpb.SliverRPC/Ps"
	SliverRPC_Terminate_FullMethodName                        = "/rpcpb.SliverRPC/Terminate"
	SliverRPC_Ifconfig_FullMethodName                         = "/rpcpb.SliverRPC/Ifconfig"
	SliverRPC_Netstat_FullMethodName                          = "/rpcpb.SliverRPC/Netstat"
	SliverRPC_Ls_FullMethodName                               = "/rpcpb.SliverRPC/Ls"
	SliverRPC_Cd_FullMethodName                               = "/rpcpb.SliverRPC/Cd"
	SliverRPC_Pwd_FullMethodName                              = "/rpcpb.SliverRPC/Pwd"
	SliverRPC_Mv_FullMethodName                               = "/rpcpb.SliverRPC/Mv"
	SliverRPC_Cp_FullMethodName                               = "/rpcpb.SliverRPC/Cp"
	SliverRPC_Rm_FullMethodName                               = "/rpcpb.SliverRPC/Rm"
	SliverRPC_Mkdir_FullMethodName                            = "/rpcpb.SliverRPC/Mkdir"
	SliverRPC_Download_FullMethodName                         = "/rpcpb.SliverRPC/Download"
	SliverRPC_Upload_FullMethodName                           = "/rpcpb.SliverRPC/Upload"
	SliverRPC_Grep_FullMethodName                             = "/rpcpb.SliverRPC/Grep"
	SliverRPC_Chmod_FullMethodName                            = "/rpcpb.SliverRPC/Chmod"
	SliverRPC_Chown_FullMethodName                            = "/rpcpb.SliverRPC/Chown"
	SliverRPC_Chtimes_FullMethodName                          = "/rpcpb.SliverRPC/Chtimes"
	SliverRPC_MemfilesList_FullMethodName                     = "/rpcpb.SliverRPC/MemfilesList"
	SliverRPC_MemfilesAdd_FullMethodName                      = "/rpcpb.SliverRPC/MemfilesAdd"
	SliverRPC_MemfilesRm_FullMethodName                       = "/rpcpb.SliverRPC/MemfilesRm"
	SliverRPC_Mount_FullMethodName                            = "/rpcpb.SliverRPC/Mount"
	SliverRPC_ProcessDump_FullMethodName                      = "/rpcpb.SliverRPC/ProcessDump"
	SliverRPC_RunAs_FullMethodName                            = "/rpcpb.SliverRPC/RunAs"
	SliverRPC_Impersonate_FullMethodName                      = "/rpcpb.SliverRPC/Impersonate"
	SliverRPC_RevToSelf_FullMethodName                        = "/rpcpb.SliverRPC/RevToSelf"
	SliverRPC_GetSystem_FullMethodName                        = "/rpcpb.SliverRPC/GetSystem"
	SliverRPC_Task_FullMethodName                             = "/rpcpb.SliverRPC/Task"
	SliverRPC_Msf_FullMethodName                              = "/rpcpb.SliverRPC/Msf"
	SliverRPC_MsfRemote_FullMethodName                        = "/rpcpb.SliverRPC/MsfRemote"
	SliverRPC_ExecuteAssembly_FullMethodName                  = "/rpcpb.SliverRPC/ExecuteAssembly"
	SliverRPC_Migrate_FullMethodName                          = "/rpcpb.SliverRPC/Migrate"
	SliverRPC_Execute_FullMethodName                          = "/rpcpb.SliverRPC/Execute"
	SliverRPC_ExecuteWindows_FullMethodName                   = "/rpcpb.SliverRPC/ExecuteWindows"
	SliverRPC_Sideload_FullMethodName                         = "/rpcpb.SliverRPC/Sideload"
	SliverRPC_SpawnDll_FullMethodName                         = "/rpcpb.SliverRPC/SpawnDll"
	SliverRPC_Screenshot_FullMethodName                       = "/rpcpb.SliverRPC/Screenshot"
	SliverRPC_CurrentTokenOwner_FullMethodName                = "/rpcpb.SliverRPC/CurrentTokenOwner"
	SliverRPC_Services_FullMethodName                         = "/rpcpb.SliverRPC/Services"
	SliverRPC_ServiceDetail_FullMethodName                    = "/rpcpb.SliverRPC/ServiceDetail"
	SliverRPC_StartServiceByName_FullMethodName               = "/rpcpb.SliverRPC/StartServiceByName"
	SliverRPC_PivotStartListener_FullMethodName               = "/rpcpb.SliverRPC/PivotStartListener"
	SliverRPC_PivotStopListener_FullMethodName                = "/rpcpb.SliverRPC/PivotStopListener"
	SliverRPC_PivotSessionListeners_FullMethodName            = "/rpcpb.SliverRPC/PivotSessionListeners"
	SliverRPC_PivotGraph_FullMethodName                       = "/rpcpb.SliverRPC/PivotGraph"
	SliverRPC_StartService_FullMethodName                     = "/rpcpb.SliverRPC/StartService"
	SliverRPC_StopService_FullMethodName                      = "/rpcpb.SliverRPC/StopService"
	SliverRPC_RemoveService_FullMethodName                    = "/rpcpb.SliverRPC/RemoveService"
	SliverRPC_MakeToken_FullMethodName                        = "/rpcpb.SliverRPC/MakeToken"
	SliverRPC_GetEnv_FullMethodName                           = "/rpcpb.SliverRPC/GetEnv"
	SliverRPC_SetEnv_FullMethodName                           = "/rpcpb.SliverRPC/SetEnv"
	SliverRPC_UnsetEnv_FullMethodName                         = "/rpcpb.SliverRPC/UnsetEnv"
	SliverRPC_Backdoor_FullMethodName                         = "/rpcpb.SliverRPC/Backdoor"
	SliverRPC_RegistryRead_FullMethodName                     = "/rpcpb.SliverRPC/RegistryRead"
	SliverRPC_RegistryWrite_FullMethodName                    = "/rpcpb.SliverRPC/RegistryWrite"
	SliverRPC_RegistryCreateKey_FullMethodName                = "/rpcpb.SliverRPC/RegistryCreateKey"
	SliverRPC_RegistryDeleteKey_FullMethodName                = "/rpcpb.SliverRPC/RegistryDeleteKey"
	SliverRPC_RegistryListSubKeys_FullMethodName              = "/rpcpb.SliverRPC/RegistryListSubKeys"
	SliverRPC_RegistryListValues_FullMethodName               = "/rpcpb.SliverRPC/RegistryListValues"
	SliverRPC_RegistryReadHive_FullMethodName                 = "/rpcpb.SliverRPC/RegistryReadHive"
	SliverRPC_RunSSHCommand_FullMethodName                    = "/rpcpb.SliverRPC/RunSSHCommand"
	SliverRPC_HijackDLL_FullMethodName                        = "/rpcpb.SliverRPC/HijackDLL"
	SliverRPC_GetPrivs_FullMethodName                         = "/rpcpb.SliverRPC/GetPrivs"
	SliverRPC_StartRportFwdListener_FullMethodName            = "/rpcpb.SliverRPC/StartRportFwdListener"
	SliverRPC_GetRportFwdListeners_FullMethodName             = "/rpcpb.SliverRPC/GetRportFwdListeners"
	SliverRPC_StopRportFwdListener_FullMethodName             = "/rpcpb.SliverRPC/StopRportFwdListener"
	SliverRPC_OpenSession_FullMethodName                      = "/rpcpb.SliverRPC/OpenSession"
	SliverRPC_CloseSession_FullMethodName                     = "/rpcpb.SliverRPC/CloseSession"
	SliverRPC_RegisterExtension_FullMethodName                = "/rpcpb.SliverRPC/RegisterExtension"
	SliverRPC_CallExtension_FullMethodName                    = "/rpcpb.SliverRPC/CallExtension"
	SliverRPC_ListExtensions_FullMethodName                   = "/rpcpb.SliverRPC/ListExtensions"
	SliverRPC_RegisterWasmExtension_FullMethodName            = "/rpcpb.SliverRPC/RegisterWasmExtension"
	SliverRPC_ListWasmExtensions_FullMethodName               = "/rpcpb.SliverRPC/ListWasmExtensions"
	SliverRPC_ExecWasmExtension_FullMethodName                = "/rpcpb.SliverRPC/ExecWasmExtension"
	SliverRPC_WGStartPortForward_FullMethodName               = "/rpcpb.SliverRPC/WGStartPortForward"
	SliverRPC_WGStopPortForward_FullMethodName                = "/rpcpb.SliverRPC/WGStopPortForward"
	SliverRPC_WGStartSocks_FullMethodName                     = "/rpcpb.SliverRPC/WGStartSocks"
	SliverRPC_WGStopSocks_FullMethodName                      = "/rpcpb.SliverRPC/WGStopSocks"
	SliverRPC_WGListForwarders_FullMethodName                 = "/rpcpb.SliverRPC/WGListForwarders"
	SliverRPC_WGListSocksServers_FullMethodName               = "/rpcpb.SliverRPC/WGListSocksServers"
	SliverRPC_Shell_FullMethodName                            = "/rpcpb.SliverRPC/Shell"
	SliverRPC_Portfwd_FullMethodName                          = "/rpcpb.SliverRPC/Portfwd"
	SliverRPC_CreateSocks_FullMethodName                      = "/rpcpb.SliverRPC/CreateSocks"
	SliverRPC_CloseSocks_FullMethodName                       = "/rpcpb.SliverRPC/CloseSocks"
	SliverRPC_SocksProxy_FullMethodName                       = "/rpcpb.SliverRPC/SocksProxy"
	SliverRPC_CreateTunnel_FullMethodName                     = "/rpcpb.SliverRPC/CreateTunnel"
	SliverRPC_CloseTunnel_FullMethodName                      = "/rpcpb.SliverRPC/CloseTunnel"
	SliverRPC_TunnelData_FullMethodName                       = "/rpcpb.SliverRPC/TunnelData"
	SliverRPC_Events_FullMethodName                           = "/rpcpb.SliverRPC/Events"
)

// SliverRPCClient is the client API for SliverRPC service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type SliverRPCClient interface {
	// *** Version ***
	GetVersion(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Version, error)
	// *** Client Logs ***
	ClientLog(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[clientpb.ClientLogData, commonpb.Empty], error)
	// *** Operator Commands ***
	GetOperators(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Operators, error)
	// *** Generic ***
	Kill(ctx context.Context, in *sliverpb.KillReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	Reconfigure(ctx context.Context, in *sliverpb.ReconfigureReq, opts ...grpc.CallOption) (*sliverpb.Reconfigure, error)
	Rename(ctx context.Context, in *clientpb.RenameReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Sessions ***
	GetSessions(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Sessions, error)
	// ***Threat monitoring ***
	MonitorStart(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*commonpb.Response, error)
	MonitorStop(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*commonpb.Empty, error)
	MonitorListConfig(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.MonitoringProviders, error)
	MonitorAddConfig(ctx context.Context, in *clientpb.MonitoringProvider, opts ...grpc.CallOption) (*commonpb.Response, error)
	MonitorDelConfig(ctx context.Context, in *clientpb.MonitoringProvider, opts ...grpc.CallOption) (*commonpb.Response, error)
	// *** Listeners ***
	StartMTLSListener(ctx context.Context, in *clientpb.MTLSListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error)
	StartWGListener(ctx context.Context, in *clientpb.WGListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error)
	StartDNSListener(ctx context.Context, in *clientpb.DNSListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error)
	StartHTTPSListener(ctx context.Context, in *clientpb.HTTPListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error)
	StartHTTPListener(ctx context.Context, in *clientpb.HTTPListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error)
	// *** Beacons ***
	GetBeacons(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Beacons, error)
	GetBeacon(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*clientpb.Beacon, error)
	RmBeacon(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*commonpb.Empty, error)
	GetBeaconTasks(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*clientpb.BeaconTasks, error)
	GetBeaconTaskContent(ctx context.Context, in *clientpb.BeaconTask, opts ...grpc.CallOption) (*clientpb.BeaconTask, error)
	CancelBeaconTask(ctx context.Context, in *clientpb.BeaconTask, opts ...grpc.CallOption) (*clientpb.BeaconTask, error)
	UpdateBeaconIntegrityInformation(ctx context.Context, in *clientpb.BeaconIntegrity, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Jobs ***
	GetJobs(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Jobs, error)
	KillJob(ctx context.Context, in *clientpb.KillJobReq, opts ...grpc.CallOption) (*clientpb.KillJob, error)
	RestartJobs(ctx context.Context, in *clientpb.RestartJobReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Stager Listener ***
	StartTCPStagerListener(ctx context.Context, in *clientpb.StagerListenerReq, opts ...grpc.CallOption) (*clientpb.StagerListener, error)
	// *** Loot ***
	LootAdd(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error)
	LootRm(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*commonpb.Empty, error)
	LootUpdate(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error)
	LootContent(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error)
	LootAll(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.AllLoot, error)
	// *** Creds ***
	Creds(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Credentials, error)
	CredsAdd(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CredsRm(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CredsUpdate(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error)
	GetCredByID(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credential, error)
	GetCredsByHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credentials, error)
	GetPlaintextCredsByHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credentials, error)
	CredsSniffHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credential, error)
	// *** Hosts ***
	Hosts(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.AllHosts, error)
	Host(ctx context.Context, in *clientpb.Host, opts ...grpc.CallOption) (*clientpb.Host, error)
	HostRm(ctx context.Context, in *clientpb.Host, opts ...grpc.CallOption) (*commonpb.Empty, error)
	HostIOCRm(ctx context.Context, in *clientpb.IOC, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Implants ***
	Generate(ctx context.Context, in *clientpb.GenerateReq, opts ...grpc.CallOption) (*clientpb.Generate, error)
	GenerateExternal(ctx context.Context, in *clientpb.ExternalGenerateReq, opts ...grpc.CallOption) (*clientpb.ExternalImplantConfig, error)
	GenerateExternalSaveBuild(ctx context.Context, in *clientpb.ExternalImplantBinary, opts ...grpc.CallOption) (*commonpb.Empty, error)
	GenerateExternalGetBuildConfig(ctx context.Context, in *clientpb.ImplantBuild, opts ...grpc.CallOption) (*clientpb.ExternalImplantConfig, error)
	GenerateStage(ctx context.Context, in *clientpb.GenerateStageReq, opts ...grpc.CallOption) (*clientpb.Generate, error)
	StageImplantBuild(ctx context.Context, in *clientpb.ImplantStageReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** HTTP C2 Profiles ***
	GetHTTPC2Profiles(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.HTTPC2Configs, error)
	GetHTTPC2ProfileByName(ctx context.Context, in *clientpb.C2ProfileReq, opts ...grpc.CallOption) (*clientpb.HTTPC2Config, error)
	SaveHTTPC2Profile(ctx context.Context, in *clientpb.HTTPC2ConfigReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Builders ***
	BuilderRegister(ctx context.Context, in *clientpb.Builder, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error)
	BuilderTrigger(ctx context.Context, in *clientpb.Event, opts ...grpc.CallOption) (*commonpb.Empty, error)
	Builders(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Builders, error)
	// *** Certificates ***
	GetCertificateInfo(ctx context.Context, in *clientpb.CertificatesReq, opts ...grpc.CallOption) (*clientpb.CertificateInfo, error)
	// *** Crackstation ***
	CrackstationRegister(ctx context.Context, in *clientpb.Crackstation, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error)
	CrackstationTrigger(ctx context.Context, in *clientpb.Event, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CrackstationBenchmark(ctx context.Context, in *clientpb.CrackBenchmark, opts ...grpc.CallOption) (*commonpb.Empty, error)
	Crackstations(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Crackstations, error)
	CrackTaskByID(ctx context.Context, in *clientpb.CrackTask, opts ...grpc.CallOption) (*clientpb.CrackTask, error)
	CrackTaskUpdate(ctx context.Context, in *clientpb.CrackTask, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CrackFilesList(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*clientpb.CrackFiles, error)
	CrackFileCreate(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*clientpb.CrackFile, error)
	CrackFileChunkUpload(ctx context.Context, in *clientpb.CrackFileChunk, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CrackFileChunkDownload(ctx context.Context, in *clientpb.CrackFileChunk, opts ...grpc.CallOption) (*clientpb.CrackFileChunk, error)
	CrackFileComplete(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*commonpb.Empty, error)
	CrackFileDelete(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Payloads ***
	Regenerate(ctx context.Context, in *clientpb.RegenerateReq, opts ...grpc.CallOption) (*clientpb.Generate, error)
	ImplantBuilds(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ImplantBuilds, error)
	DeleteImplantBuild(ctx context.Context, in *clientpb.DeleteReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	Canaries(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Canaries, error)
	GenerateWGClientConfig(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.WGClientConfig, error)
	GenerateUniqueIP(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.UniqueWGIP, error)
	ImplantProfiles(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ImplantProfiles, error)
	DeleteImplantProfile(ctx context.Context, in *clientpb.DeleteReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	SaveImplantProfile(ctx context.Context, in *clientpb.ImplantProfile, opts ...grpc.CallOption) (*clientpb.ImplantProfile, error)
	ShellcodeRDI(ctx context.Context, in *clientpb.ShellcodeRDIReq, opts ...grpc.CallOption) (*clientpb.ShellcodeRDI, error)
	GetCompiler(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Compiler, error)
	ShellcodeEncoder(ctx context.Context, in *clientpb.ShellcodeEncodeReq, opts ...grpc.CallOption) (*clientpb.ShellcodeEncode, error)
	ShellcodeEncoderMap(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ShellcodeEncoderMap, error)
	TrafficEncoderMap(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.TrafficEncoderMap, error)
	TrafficEncoderAdd(ctx context.Context, in *clientpb.TrafficEncoder, opts ...grpc.CallOption) (*clientpb.TrafficEncoderTests, error)
	TrafficEncoderRm(ctx context.Context, in *clientpb.TrafficEncoder, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Websites ***
	Websites(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Websites, error)
	Website(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.Website, error)
	WebsiteRemove(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*commonpb.Empty, error)
	WebsiteAddContent(ctx context.Context, in *clientpb.WebsiteAddContent, opts ...grpc.CallOption) (*clientpb.Website, error)
	WebsiteUpdateContent(ctx context.Context, in *clientpb.WebsiteAddContent, opts ...grpc.CallOption) (*clientpb.Website, error)
	WebsiteRemoveContent(ctx context.Context, in *clientpb.WebsiteRemoveContent, opts ...grpc.CallOption) (*clientpb.Website, error)
	// *** Session Interactions ***
	Ping(ctx context.Context, in *sliverpb.Ping, opts ...grpc.CallOption) (*sliverpb.Ping, error)
	Ps(ctx context.Context, in *sliverpb.PsReq, opts ...grpc.CallOption) (*sliverpb.Ps, error)
	Terminate(ctx context.Context, in *sliverpb.TerminateReq, opts ...grpc.CallOption) (*sliverpb.Terminate, error)
	Ifconfig(ctx context.Context, in *sliverpb.IfconfigReq, opts ...grpc.CallOption) (*sliverpb.Ifconfig, error)
	Netstat(ctx context.Context, in *sliverpb.NetstatReq, opts ...grpc.CallOption) (*sliverpb.Netstat, error)
	Ls(ctx context.Context, in *sliverpb.LsReq, opts ...grpc.CallOption) (*sliverpb.Ls, error)
	Cd(ctx context.Context, in *sliverpb.CdReq, opts ...grpc.CallOption) (*sliverpb.Pwd, error)
	Pwd(ctx context.Context, in *sliverpb.PwdReq, opts ...grpc.CallOption) (*sliverpb.Pwd, error)
	Mv(ctx context.Context, in *sliverpb.MvReq, opts ...grpc.CallOption) (*sliverpb.Mv, error)
	Cp(ctx context.Context, in *sliverpb.CpReq, opts ...grpc.CallOption) (*sliverpb.Cp, error)
	Rm(ctx context.Context, in *sliverpb.RmReq, opts ...grpc.CallOption) (*sliverpb.Rm, error)
	Mkdir(ctx context.Context, in *sliverpb.MkdirReq, opts ...grpc.CallOption) (*sliverpb.Mkdir, error)
	Download(ctx context.Context, in *sliverpb.DownloadReq, opts ...grpc.CallOption) (*sliverpb.Download, error)
	Upload(ctx context.Context, in *sliverpb.UploadReq, opts ...grpc.CallOption) (*sliverpb.Upload, error)
	Grep(ctx context.Context, in *sliverpb.GrepReq, opts ...grpc.CallOption) (*sliverpb.Grep, error)
	Chmod(ctx context.Context, in *sliverpb.ChmodReq, opts ...grpc.CallOption) (*sliverpb.Chmod, error)
	Chown(ctx context.Context, in *sliverpb.ChownReq, opts ...grpc.CallOption) (*sliverpb.Chown, error)
	Chtimes(ctx context.Context, in *sliverpb.ChtimesReq, opts ...grpc.CallOption) (*sliverpb.Chtimes, error)
	MemfilesList(ctx context.Context, in *sliverpb.MemfilesListReq, opts ...grpc.CallOption) (*sliverpb.Ls, error)
	MemfilesAdd(ctx context.Context, in *sliverpb.MemfilesAddReq, opts ...grpc.CallOption) (*sliverpb.MemfilesAdd, error)
	MemfilesRm(ctx context.Context, in *sliverpb.MemfilesRmReq, opts ...grpc.CallOption) (*sliverpb.MemfilesRm, error)
	Mount(ctx context.Context, in *sliverpb.MountReq, opts ...grpc.CallOption) (*sliverpb.Mount, error)
	ProcessDump(ctx context.Context, in *sliverpb.ProcessDumpReq, opts ...grpc.CallOption) (*sliverpb.ProcessDump, error)
	RunAs(ctx context.Context, in *sliverpb.RunAsReq, opts ...grpc.CallOption) (*sliverpb.RunAs, error)
	Impersonate(ctx context.Context, in *sliverpb.ImpersonateReq, opts ...grpc.CallOption) (*sliverpb.Impersonate, error)
	RevToSelf(ctx context.Context, in *sliverpb.RevToSelfReq, opts ...grpc.CallOption) (*sliverpb.RevToSelf, error)
	GetSystem(ctx context.Context, in *clientpb.GetSystemReq, opts ...grpc.CallOption) (*sliverpb.GetSystem, error)
	Task(ctx context.Context, in *sliverpb.TaskReq, opts ...grpc.CallOption) (*sliverpb.Task, error)
	Msf(ctx context.Context, in *clientpb.MSFReq, opts ...grpc.CallOption) (*sliverpb.Task, error)
	MsfRemote(ctx context.Context, in *clientpb.MSFRemoteReq, opts ...grpc.CallOption) (*sliverpb.Task, error)
	ExecuteAssembly(ctx context.Context, in *sliverpb.ExecuteAssemblyReq, opts ...grpc.CallOption) (*sliverpb.ExecuteAssembly, error)
	Migrate(ctx context.Context, in *clientpb.MigrateReq, opts ...grpc.CallOption) (*sliverpb.Migrate, error)
	Execute(ctx context.Context, in *sliverpb.ExecuteReq, opts ...grpc.CallOption) (*sliverpb.Execute, error)
	ExecuteWindows(ctx context.Context, in *sliverpb.ExecuteWindowsReq, opts ...grpc.CallOption) (*sliverpb.Execute, error)
	Sideload(ctx context.Context, in *sliverpb.SideloadReq, opts ...grpc.CallOption) (*sliverpb.Sideload, error)
	SpawnDll(ctx context.Context, in *sliverpb.InvokeSpawnDllReq, opts ...grpc.CallOption) (*sliverpb.SpawnDll, error)
	Screenshot(ctx context.Context, in *sliverpb.ScreenshotReq, opts ...grpc.CallOption) (*sliverpb.Screenshot, error)
	CurrentTokenOwner(ctx context.Context, in *sliverpb.CurrentTokenOwnerReq, opts ...grpc.CallOption) (*sliverpb.CurrentTokenOwner, error)
	Services(ctx context.Context, in *sliverpb.ServicesReq, opts ...grpc.CallOption) (*sliverpb.Services, error)
	ServiceDetail(ctx context.Context, in *sliverpb.ServiceDetailReq, opts ...grpc.CallOption) (*sliverpb.ServiceDetail, error)
	StartServiceByName(ctx context.Context, in *sliverpb.StartServiceByNameReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error)
	// *** Pivots ***
	PivotStartListener(ctx context.Context, in *sliverpb.PivotStartListenerReq, opts ...grpc.CallOption) (*sliverpb.PivotListener, error)
	PivotStopListener(ctx context.Context, in *sliverpb.PivotStopListenerReq, opts ...grpc.CallOption) (*commonpb.Empty, error)
	PivotSessionListeners(ctx context.Context, in *sliverpb.PivotListenersReq, opts ...grpc.CallOption) (*sliverpb.PivotListeners, error)
	PivotGraph(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.PivotGraph, error)
	StartService(ctx context.Context, in *sliverpb.StartServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error)
	StopService(ctx context.Context, in *sliverpb.StopServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error)
	RemoveService(ctx context.Context, in *sliverpb.RemoveServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error)
	MakeToken(ctx context.Context, in *sliverpb.MakeTokenReq, opts ...grpc.CallOption) (*sliverpb.MakeToken, error)
	GetEnv(ctx context.Context, in *sliverpb.EnvReq, opts ...grpc.CallOption) (*sliverpb.EnvInfo, error)
	SetEnv(ctx context.Context, in *sliverpb.SetEnvReq, opts ...grpc.CallOption) (*sliverpb.SetEnv, error)
	UnsetEnv(ctx context.Context, in *sliverpb.UnsetEnvReq, opts ...grpc.CallOption) (*sliverpb.UnsetEnv, error)
	Backdoor(ctx context.Context, in *clientpb.BackdoorReq, opts ...grpc.CallOption) (*clientpb.Backdoor, error)
	RegistryRead(ctx context.Context, in *sliverpb.RegistryReadReq, opts ...grpc.CallOption) (*sliverpb.RegistryRead, error)
	RegistryWrite(ctx context.Context, in *sliverpb.RegistryWriteReq, opts ...grpc.CallOption) (*sliverpb.RegistryWrite, error)
	RegistryCreateKey(ctx context.Context, in *sliverpb.RegistryCreateKeyReq, opts ...grpc.CallOption) (*sliverpb.RegistryCreateKey, error)
	RegistryDeleteKey(ctx context.Context, in *sliverpb.RegistryDeleteKeyReq, opts ...grpc.CallOption) (*sliverpb.RegistryDeleteKey, error)
	RegistryListSubKeys(ctx context.Context, in *sliverpb.RegistrySubKeyListReq, opts ...grpc.CallOption) (*sliverpb.RegistrySubKeyList, error)
	RegistryListValues(ctx context.Context, in *sliverpb.RegistryListValuesReq, opts ...grpc.CallOption) (*sliverpb.RegistryValuesList, error)
	RegistryReadHive(ctx context.Context, in *sliverpb.RegistryReadHiveReq, opts ...grpc.CallOption) (*sliverpb.RegistryReadHive, error)
	RunSSHCommand(ctx context.Context, in *sliverpb.SSHCommandReq, opts ...grpc.CallOption) (*sliverpb.SSHCommand, error)
	HijackDLL(ctx context.Context, in *clientpb.DllHijackReq, opts ...grpc.CallOption) (*clientpb.DllHijack, error)
	GetPrivs(ctx context.Context, in *sliverpb.GetPrivsReq, opts ...grpc.CallOption) (*sliverpb.GetPrivs, error)
	StartRportFwdListener(ctx context.Context, in *sliverpb.RportFwdStartListenerReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListener, error)
	GetRportFwdListeners(ctx context.Context, in *sliverpb.RportFwdListenersReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListeners, error)
	StopRportFwdListener(ctx context.Context, in *sliverpb.RportFwdStopListenerReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListener, error)
	// *** Beacon *** -only commands
	OpenSession(ctx context.Context, in *sliverpb.OpenSession, opts ...grpc.CallOption) (*sliverpb.OpenSession, error)
	CloseSession(ctx context.Context, in *sliverpb.CloseSession, opts ...grpc.CallOption) (*commonpb.Empty, error)
	// *** Extensions ***
	RegisterExtension(ctx context.Context, in *sliverpb.RegisterExtensionReq, opts ...grpc.CallOption) (*sliverpb.RegisterExtension, error)
	CallExtension(ctx context.Context, in *sliverpb.CallExtensionReq, opts ...grpc.CallOption) (*sliverpb.CallExtension, error)
	ListExtensions(ctx context.Context, in *sliverpb.ListExtensionsReq, opts ...grpc.CallOption) (*sliverpb.ListExtensions, error)
	// *** Wasm Extensions ***
	RegisterWasmExtension(ctx context.Context, in *sliverpb.RegisterWasmExtensionReq, opts ...grpc.CallOption) (*sliverpb.RegisterWasmExtension, error)
	ListWasmExtensions(ctx context.Context, in *sliverpb.ListWasmExtensionsReq, opts ...grpc.CallOption) (*sliverpb.ListWasmExtensions, error)
	ExecWasmExtension(ctx context.Context, in *sliverpb.ExecWasmExtensionReq, opts ...grpc.CallOption) (*sliverpb.ExecWasmExtension, error)
	// *** Wireguard Specific ***
	WGStartPortForward(ctx context.Context, in *sliverpb.WGPortForwardStartReq, opts ...grpc.CallOption) (*sliverpb.WGPortForward, error)
	WGStopPortForward(ctx context.Context, in *sliverpb.WGPortForwardStopReq, opts ...grpc.CallOption) (*sliverpb.WGPortForward, error)
	WGStartSocks(ctx context.Context, in *sliverpb.WGSocksStartReq, opts ...grpc.CallOption) (*sliverpb.WGSocks, error)
	WGStopSocks(ctx context.Context, in *sliverpb.WGSocksStopReq, opts ...grpc.CallOption) (*sliverpb.WGSocks, error)
	WGListForwarders(ctx context.Context, in *sliverpb.WGTCPForwardersReq, opts ...grpc.CallOption) (*sliverpb.WGTCPForwarders, error)
	WGListSocksServers(ctx context.Context, in *sliverpb.WGSocksServersReq, opts ...grpc.CallOption) (*sliverpb.WGSocksServers, error)
	// *** Realtime Commands ***
	Shell(ctx context.Context, in *sliverpb.ShellReq, opts ...grpc.CallOption) (*sliverpb.Shell, error)
	Portfwd(ctx context.Context, in *sliverpb.PortfwdReq, opts ...grpc.CallOption) (*sliverpb.Portfwd, error)
	// *** Socks5 ***
	CreateSocks(ctx context.Context, in *sliverpb.Socks, opts ...grpc.CallOption) (*sliverpb.Socks, error)
	CloseSocks(ctx context.Context, in *sliverpb.Socks, opts ...grpc.CallOption) (*commonpb.Empty, error)
	SocksProxy(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[sliverpb.SocksData, sliverpb.SocksData], error)
	// *** Tunnels ***
	CreateTunnel(ctx context.Context, in *sliverpb.Tunnel, opts ...grpc.CallOption) (*sliverpb.Tunnel, error)
	CloseTunnel(ctx context.Context, in *sliverpb.Tunnel, opts ...grpc.CallOption) (*commonpb.Empty, error)
	TunnelData(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[sliverpb.TunnelData, sliverpb.TunnelData], error)
	// *** Events ***
	Events(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error)
}

type sliverRPCClient struct {
	cc grpc.ClientConnInterface
}

func NewSliverRPCClient(cc grpc.ClientConnInterface) SliverRPCClient {
	return &sliverRPCClient{cc}
}

func (c *sliverRPCClient) GetVersion(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Version, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Version)
	err := c.cc.Invoke(ctx, SliverRPC_GetVersion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ClientLog(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[clientpb.ClientLogData, commonpb.Empty], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[0], SliverRPC_ClientLog_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[clientpb.ClientLogData, commonpb.Empty]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_ClientLogClient = grpc.ClientStreamingClient[clientpb.ClientLogData, commonpb.Empty]

func (c *sliverRPCClient) GetOperators(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Operators, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Operators)
	err := c.cc.Invoke(ctx, SliverRPC_GetOperators_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Kill(ctx context.Context, in *sliverpb.KillReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_Kill_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Reconfigure(ctx context.Context, in *sliverpb.ReconfigureReq, opts ...grpc.CallOption) (*sliverpb.Reconfigure, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Reconfigure)
	err := c.cc.Invoke(ctx, SliverRPC_Reconfigure_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Rename(ctx context.Context, in *clientpb.RenameReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_Rename_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetSessions(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Sessions, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Sessions)
	err := c.cc.Invoke(ctx, SliverRPC_GetSessions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MonitorStart(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*commonpb.Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Response)
	err := c.cc.Invoke(ctx, SliverRPC_MonitorStart_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MonitorStop(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_MonitorStop_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MonitorListConfig(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.MonitoringProviders, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.MonitoringProviders)
	err := c.cc.Invoke(ctx, SliverRPC_MonitorListConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MonitorAddConfig(ctx context.Context, in *clientpb.MonitoringProvider, opts ...grpc.CallOption) (*commonpb.Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Response)
	err := c.cc.Invoke(ctx, SliverRPC_MonitorAddConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MonitorDelConfig(ctx context.Context, in *clientpb.MonitoringProvider, opts ...grpc.CallOption) (*commonpb.Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Response)
	err := c.cc.Invoke(ctx, SliverRPC_MonitorDelConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartMTLSListener(ctx context.Context, in *clientpb.MTLSListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ListenerJob)
	err := c.cc.Invoke(ctx, SliverRPC_StartMTLSListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartWGListener(ctx context.Context, in *clientpb.WGListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ListenerJob)
	err := c.cc.Invoke(ctx, SliverRPC_StartWGListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartDNSListener(ctx context.Context, in *clientpb.DNSListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ListenerJob)
	err := c.cc.Invoke(ctx, SliverRPC_StartDNSListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartHTTPSListener(ctx context.Context, in *clientpb.HTTPListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ListenerJob)
	err := c.cc.Invoke(ctx, SliverRPC_StartHTTPSListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartHTTPListener(ctx context.Context, in *clientpb.HTTPListenerReq, opts ...grpc.CallOption) (*clientpb.ListenerJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ListenerJob)
	err := c.cc.Invoke(ctx, SliverRPC_StartHTTPListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetBeacons(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Beacons, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Beacons)
	err := c.cc.Invoke(ctx, SliverRPC_GetBeacons_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetBeacon(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*clientpb.Beacon, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Beacon)
	err := c.cc.Invoke(ctx, SliverRPC_GetBeacon_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RmBeacon(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_RmBeacon_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetBeaconTasks(ctx context.Context, in *clientpb.Beacon, opts ...grpc.CallOption) (*clientpb.BeaconTasks, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.BeaconTasks)
	err := c.cc.Invoke(ctx, SliverRPC_GetBeaconTasks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetBeaconTaskContent(ctx context.Context, in *clientpb.BeaconTask, opts ...grpc.CallOption) (*clientpb.BeaconTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.BeaconTask)
	err := c.cc.Invoke(ctx, SliverRPC_GetBeaconTaskContent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CancelBeaconTask(ctx context.Context, in *clientpb.BeaconTask, opts ...grpc.CallOption) (*clientpb.BeaconTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.BeaconTask)
	err := c.cc.Invoke(ctx, SliverRPC_CancelBeaconTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) UpdateBeaconIntegrityInformation(ctx context.Context, in *clientpb.BeaconIntegrity, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_UpdateBeaconIntegrityInformation_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetJobs(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Jobs, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Jobs)
	err := c.cc.Invoke(ctx, SliverRPC_GetJobs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) KillJob(ctx context.Context, in *clientpb.KillJobReq, opts ...grpc.CallOption) (*clientpb.KillJob, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.KillJob)
	err := c.cc.Invoke(ctx, SliverRPC_KillJob_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RestartJobs(ctx context.Context, in *clientpb.RestartJobReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_RestartJobs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartTCPStagerListener(ctx context.Context, in *clientpb.StagerListenerReq, opts ...grpc.CallOption) (*clientpb.StagerListener, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.StagerListener)
	err := c.cc.Invoke(ctx, SliverRPC_StartTCPStagerListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) LootAdd(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Loot)
	err := c.cc.Invoke(ctx, SliverRPC_LootAdd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) LootRm(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_LootRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) LootUpdate(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Loot)
	err := c.cc.Invoke(ctx, SliverRPC_LootUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) LootContent(ctx context.Context, in *clientpb.Loot, opts ...grpc.CallOption) (*clientpb.Loot, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Loot)
	err := c.cc.Invoke(ctx, SliverRPC_LootContent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) LootAll(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.AllLoot, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.AllLoot)
	err := c.cc.Invoke(ctx, SliverRPC_LootAll_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Creds(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Credentials, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Credentials)
	err := c.cc.Invoke(ctx, SliverRPC_Creds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CredsAdd(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CredsAdd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CredsRm(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CredsRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CredsUpdate(ctx context.Context, in *clientpb.Credentials, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CredsUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetCredByID(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credential, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Credential)
	err := c.cc.Invoke(ctx, SliverRPC_GetCredByID_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetCredsByHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credentials, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Credentials)
	err := c.cc.Invoke(ctx, SliverRPC_GetCredsByHashType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetPlaintextCredsByHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credentials, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Credentials)
	err := c.cc.Invoke(ctx, SliverRPC_GetPlaintextCredsByHashType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CredsSniffHashType(ctx context.Context, in *clientpb.Credential, opts ...grpc.CallOption) (*clientpb.Credential, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Credential)
	err := c.cc.Invoke(ctx, SliverRPC_CredsSniffHashType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Hosts(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.AllHosts, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.AllHosts)
	err := c.cc.Invoke(ctx, SliverRPC_Hosts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Host(ctx context.Context, in *clientpb.Host, opts ...grpc.CallOption) (*clientpb.Host, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Host)
	err := c.cc.Invoke(ctx, SliverRPC_Host_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) HostRm(ctx context.Context, in *clientpb.Host, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_HostRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) HostIOCRm(ctx context.Context, in *clientpb.IOC, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_HostIOCRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Generate(ctx context.Context, in *clientpb.GenerateReq, opts ...grpc.CallOption) (*clientpb.Generate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Generate)
	err := c.cc.Invoke(ctx, SliverRPC_Generate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateExternal(ctx context.Context, in *clientpb.ExternalGenerateReq, opts ...grpc.CallOption) (*clientpb.ExternalImplantConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ExternalImplantConfig)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateExternal_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateExternalSaveBuild(ctx context.Context, in *clientpb.ExternalImplantBinary, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateExternalSaveBuild_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateExternalGetBuildConfig(ctx context.Context, in *clientpb.ImplantBuild, opts ...grpc.CallOption) (*clientpb.ExternalImplantConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ExternalImplantConfig)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateExternalGetBuildConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateStage(ctx context.Context, in *clientpb.GenerateStageReq, opts ...grpc.CallOption) (*clientpb.Generate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Generate)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateStage_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StageImplantBuild(ctx context.Context, in *clientpb.ImplantStageReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_StageImplantBuild_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetHTTPC2Profiles(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.HTTPC2Configs, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.HTTPC2Configs)
	err := c.cc.Invoke(ctx, SliverRPC_GetHTTPC2Profiles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetHTTPC2ProfileByName(ctx context.Context, in *clientpb.C2ProfileReq, opts ...grpc.CallOption) (*clientpb.HTTPC2Config, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.HTTPC2Config)
	err := c.cc.Invoke(ctx, SliverRPC_GetHTTPC2ProfileByName_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) SaveHTTPC2Profile(ctx context.Context, in *clientpb.HTTPC2ConfigReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_SaveHTTPC2Profile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) BuilderRegister(ctx context.Context, in *clientpb.Builder, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[1], SliverRPC_BuilderRegister_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[clientpb.Builder, clientpb.Event]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_BuilderRegisterClient = grpc.ServerStreamingClient[clientpb.Event]

func (c *sliverRPCClient) BuilderTrigger(ctx context.Context, in *clientpb.Event, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_BuilderTrigger_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Builders(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Builders, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Builders)
	err := c.cc.Invoke(ctx, SliverRPC_Builders_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetCertificateInfo(ctx context.Context, in *clientpb.CertificatesReq, opts ...grpc.CallOption) (*clientpb.CertificateInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.CertificateInfo)
	err := c.cc.Invoke(ctx, SliverRPC_GetCertificateInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackstationRegister(ctx context.Context, in *clientpb.Crackstation, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[2], SliverRPC_CrackstationRegister_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[clientpb.Crackstation, clientpb.Event]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_CrackstationRegisterClient = grpc.ServerStreamingClient[clientpb.Event]

func (c *sliverRPCClient) CrackstationTrigger(ctx context.Context, in *clientpb.Event, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackstationTrigger_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackstationBenchmark(ctx context.Context, in *clientpb.CrackBenchmark, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackstationBenchmark_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Crackstations(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Crackstations, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Crackstations)
	err := c.cc.Invoke(ctx, SliverRPC_Crackstations_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackTaskByID(ctx context.Context, in *clientpb.CrackTask, opts ...grpc.CallOption) (*clientpb.CrackTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.CrackTask)
	err := c.cc.Invoke(ctx, SliverRPC_CrackTaskByID_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackTaskUpdate(ctx context.Context, in *clientpb.CrackTask, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackTaskUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFilesList(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*clientpb.CrackFiles, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.CrackFiles)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFilesList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFileCreate(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*clientpb.CrackFile, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.CrackFile)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFileCreate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFileChunkUpload(ctx context.Context, in *clientpb.CrackFileChunk, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFileChunkUpload_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFileChunkDownload(ctx context.Context, in *clientpb.CrackFileChunk, opts ...grpc.CallOption) (*clientpb.CrackFileChunk, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.CrackFileChunk)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFileChunkDownload_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFileComplete(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFileComplete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CrackFileDelete(ctx context.Context, in *clientpb.CrackFile, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CrackFileDelete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Regenerate(ctx context.Context, in *clientpb.RegenerateReq, opts ...grpc.CallOption) (*clientpb.Generate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Generate)
	err := c.cc.Invoke(ctx, SliverRPC_Regenerate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ImplantBuilds(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ImplantBuilds, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ImplantBuilds)
	err := c.cc.Invoke(ctx, SliverRPC_ImplantBuilds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) DeleteImplantBuild(ctx context.Context, in *clientpb.DeleteReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_DeleteImplantBuild_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Canaries(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Canaries, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Canaries)
	err := c.cc.Invoke(ctx, SliverRPC_Canaries_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateWGClientConfig(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.WGClientConfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.WGClientConfig)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateWGClientConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GenerateUniqueIP(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.UniqueWGIP, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.UniqueWGIP)
	err := c.cc.Invoke(ctx, SliverRPC_GenerateUniqueIP_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ImplantProfiles(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ImplantProfiles, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ImplantProfiles)
	err := c.cc.Invoke(ctx, SliverRPC_ImplantProfiles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) DeleteImplantProfile(ctx context.Context, in *clientpb.DeleteReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_DeleteImplantProfile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) SaveImplantProfile(ctx context.Context, in *clientpb.ImplantProfile, opts ...grpc.CallOption) (*clientpb.ImplantProfile, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ImplantProfile)
	err := c.cc.Invoke(ctx, SliverRPC_SaveImplantProfile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ShellcodeRDI(ctx context.Context, in *clientpb.ShellcodeRDIReq, opts ...grpc.CallOption) (*clientpb.ShellcodeRDI, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ShellcodeRDI)
	err := c.cc.Invoke(ctx, SliverRPC_ShellcodeRDI_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetCompiler(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Compiler, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Compiler)
	err := c.cc.Invoke(ctx, SliverRPC_GetCompiler_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ShellcodeEncoder(ctx context.Context, in *clientpb.ShellcodeEncodeReq, opts ...grpc.CallOption) (*clientpb.ShellcodeEncode, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ShellcodeEncode)
	err := c.cc.Invoke(ctx, SliverRPC_ShellcodeEncoder_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ShellcodeEncoderMap(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.ShellcodeEncoderMap, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.ShellcodeEncoderMap)
	err := c.cc.Invoke(ctx, SliverRPC_ShellcodeEncoderMap_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) TrafficEncoderMap(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.TrafficEncoderMap, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.TrafficEncoderMap)
	err := c.cc.Invoke(ctx, SliverRPC_TrafficEncoderMap_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) TrafficEncoderAdd(ctx context.Context, in *clientpb.TrafficEncoder, opts ...grpc.CallOption) (*clientpb.TrafficEncoderTests, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.TrafficEncoderTests)
	err := c.cc.Invoke(ctx, SliverRPC_TrafficEncoderAdd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) TrafficEncoderRm(ctx context.Context, in *clientpb.TrafficEncoder, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_TrafficEncoderRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Websites(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.Websites, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Websites)
	err := c.cc.Invoke(ctx, SliverRPC_Websites_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Website(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.Website, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Website)
	err := c.cc.Invoke(ctx, SliverRPC_Website_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WebsiteRemove(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_WebsiteRemove_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WebsiteAddContent(ctx context.Context, in *clientpb.WebsiteAddContent, opts ...grpc.CallOption) (*clientpb.Website, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Website)
	err := c.cc.Invoke(ctx, SliverRPC_WebsiteAddContent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WebsiteUpdateContent(ctx context.Context, in *clientpb.WebsiteAddContent, opts ...grpc.CallOption) (*clientpb.Website, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Website)
	err := c.cc.Invoke(ctx, SliverRPC_WebsiteUpdateContent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WebsiteRemoveContent(ctx context.Context, in *clientpb.WebsiteRemoveContent, opts ...grpc.CallOption) (*clientpb.Website, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Website)
	err := c.cc.Invoke(ctx, SliverRPC_WebsiteRemoveContent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Ping(ctx context.Context, in *sliverpb.Ping, opts ...grpc.CallOption) (*sliverpb.Ping, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Ping)
	err := c.cc.Invoke(ctx, SliverRPC_Ping_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Ps(ctx context.Context, in *sliverpb.PsReq, opts ...grpc.CallOption) (*sliverpb.Ps, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Ps)
	err := c.cc.Invoke(ctx, SliverRPC_Ps_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Terminate(ctx context.Context, in *sliverpb.TerminateReq, opts ...grpc.CallOption) (*sliverpb.Terminate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Terminate)
	err := c.cc.Invoke(ctx, SliverRPC_Terminate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Ifconfig(ctx context.Context, in *sliverpb.IfconfigReq, opts ...grpc.CallOption) (*sliverpb.Ifconfig, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Ifconfig)
	err := c.cc.Invoke(ctx, SliverRPC_Ifconfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Netstat(ctx context.Context, in *sliverpb.NetstatReq, opts ...grpc.CallOption) (*sliverpb.Netstat, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Netstat)
	err := c.cc.Invoke(ctx, SliverRPC_Netstat_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Ls(ctx context.Context, in *sliverpb.LsReq, opts ...grpc.CallOption) (*sliverpb.Ls, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Ls)
	err := c.cc.Invoke(ctx, SliverRPC_Ls_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Cd(ctx context.Context, in *sliverpb.CdReq, opts ...grpc.CallOption) (*sliverpb.Pwd, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Pwd)
	err := c.cc.Invoke(ctx, SliverRPC_Cd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Pwd(ctx context.Context, in *sliverpb.PwdReq, opts ...grpc.CallOption) (*sliverpb.Pwd, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Pwd)
	err := c.cc.Invoke(ctx, SliverRPC_Pwd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Mv(ctx context.Context, in *sliverpb.MvReq, opts ...grpc.CallOption) (*sliverpb.Mv, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Mv)
	err := c.cc.Invoke(ctx, SliverRPC_Mv_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Cp(ctx context.Context, in *sliverpb.CpReq, opts ...grpc.CallOption) (*sliverpb.Cp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Cp)
	err := c.cc.Invoke(ctx, SliverRPC_Cp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Rm(ctx context.Context, in *sliverpb.RmReq, opts ...grpc.CallOption) (*sliverpb.Rm, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Rm)
	err := c.cc.Invoke(ctx, SliverRPC_Rm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Mkdir(ctx context.Context, in *sliverpb.MkdirReq, opts ...grpc.CallOption) (*sliverpb.Mkdir, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Mkdir)
	err := c.cc.Invoke(ctx, SliverRPC_Mkdir_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Download(ctx context.Context, in *sliverpb.DownloadReq, opts ...grpc.CallOption) (*sliverpb.Download, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Download)
	err := c.cc.Invoke(ctx, SliverRPC_Download_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Upload(ctx context.Context, in *sliverpb.UploadReq, opts ...grpc.CallOption) (*sliverpb.Upload, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Upload)
	err := c.cc.Invoke(ctx, SliverRPC_Upload_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Grep(ctx context.Context, in *sliverpb.GrepReq, opts ...grpc.CallOption) (*sliverpb.Grep, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Grep)
	err := c.cc.Invoke(ctx, SliverRPC_Grep_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Chmod(ctx context.Context, in *sliverpb.ChmodReq, opts ...grpc.CallOption) (*sliverpb.Chmod, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Chmod)
	err := c.cc.Invoke(ctx, SliverRPC_Chmod_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Chown(ctx context.Context, in *sliverpb.ChownReq, opts ...grpc.CallOption) (*sliverpb.Chown, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Chown)
	err := c.cc.Invoke(ctx, SliverRPC_Chown_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Chtimes(ctx context.Context, in *sliverpb.ChtimesReq, opts ...grpc.CallOption) (*sliverpb.Chtimes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Chtimes)
	err := c.cc.Invoke(ctx, SliverRPC_Chtimes_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MemfilesList(ctx context.Context, in *sliverpb.MemfilesListReq, opts ...grpc.CallOption) (*sliverpb.Ls, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Ls)
	err := c.cc.Invoke(ctx, SliverRPC_MemfilesList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MemfilesAdd(ctx context.Context, in *sliverpb.MemfilesAddReq, opts ...grpc.CallOption) (*sliverpb.MemfilesAdd, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.MemfilesAdd)
	err := c.cc.Invoke(ctx, SliverRPC_MemfilesAdd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MemfilesRm(ctx context.Context, in *sliverpb.MemfilesRmReq, opts ...grpc.CallOption) (*sliverpb.MemfilesRm, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.MemfilesRm)
	err := c.cc.Invoke(ctx, SliverRPC_MemfilesRm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Mount(ctx context.Context, in *sliverpb.MountReq, opts ...grpc.CallOption) (*sliverpb.Mount, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Mount)
	err := c.cc.Invoke(ctx, SliverRPC_Mount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ProcessDump(ctx context.Context, in *sliverpb.ProcessDumpReq, opts ...grpc.CallOption) (*sliverpb.ProcessDump, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ProcessDump)
	err := c.cc.Invoke(ctx, SliverRPC_ProcessDump_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RunAs(ctx context.Context, in *sliverpb.RunAsReq, opts ...grpc.CallOption) (*sliverpb.RunAs, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RunAs)
	err := c.cc.Invoke(ctx, SliverRPC_RunAs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Impersonate(ctx context.Context, in *sliverpb.ImpersonateReq, opts ...grpc.CallOption) (*sliverpb.Impersonate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Impersonate)
	err := c.cc.Invoke(ctx, SliverRPC_Impersonate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RevToSelf(ctx context.Context, in *sliverpb.RevToSelfReq, opts ...grpc.CallOption) (*sliverpb.RevToSelf, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RevToSelf)
	err := c.cc.Invoke(ctx, SliverRPC_RevToSelf_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetSystem(ctx context.Context, in *clientpb.GetSystemReq, opts ...grpc.CallOption) (*sliverpb.GetSystem, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.GetSystem)
	err := c.cc.Invoke(ctx, SliverRPC_GetSystem_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Task(ctx context.Context, in *sliverpb.TaskReq, opts ...grpc.CallOption) (*sliverpb.Task, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Task)
	err := c.cc.Invoke(ctx, SliverRPC_Task_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Msf(ctx context.Context, in *clientpb.MSFReq, opts ...grpc.CallOption) (*sliverpb.Task, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Task)
	err := c.cc.Invoke(ctx, SliverRPC_Msf_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MsfRemote(ctx context.Context, in *clientpb.MSFRemoteReq, opts ...grpc.CallOption) (*sliverpb.Task, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Task)
	err := c.cc.Invoke(ctx, SliverRPC_MsfRemote_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ExecuteAssembly(ctx context.Context, in *sliverpb.ExecuteAssemblyReq, opts ...grpc.CallOption) (*sliverpb.ExecuteAssembly, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ExecuteAssembly)
	err := c.cc.Invoke(ctx, SliverRPC_ExecuteAssembly_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Migrate(ctx context.Context, in *clientpb.MigrateReq, opts ...grpc.CallOption) (*sliverpb.Migrate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Migrate)
	err := c.cc.Invoke(ctx, SliverRPC_Migrate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Execute(ctx context.Context, in *sliverpb.ExecuteReq, opts ...grpc.CallOption) (*sliverpb.Execute, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Execute)
	err := c.cc.Invoke(ctx, SliverRPC_Execute_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ExecuteWindows(ctx context.Context, in *sliverpb.ExecuteWindowsReq, opts ...grpc.CallOption) (*sliverpb.Execute, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Execute)
	err := c.cc.Invoke(ctx, SliverRPC_ExecuteWindows_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Sideload(ctx context.Context, in *sliverpb.SideloadReq, opts ...grpc.CallOption) (*sliverpb.Sideload, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Sideload)
	err := c.cc.Invoke(ctx, SliverRPC_Sideload_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) SpawnDll(ctx context.Context, in *sliverpb.InvokeSpawnDllReq, opts ...grpc.CallOption) (*sliverpb.SpawnDll, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.SpawnDll)
	err := c.cc.Invoke(ctx, SliverRPC_SpawnDll_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Screenshot(ctx context.Context, in *sliverpb.ScreenshotReq, opts ...grpc.CallOption) (*sliverpb.Screenshot, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Screenshot)
	err := c.cc.Invoke(ctx, SliverRPC_Screenshot_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CurrentTokenOwner(ctx context.Context, in *sliverpb.CurrentTokenOwnerReq, opts ...grpc.CallOption) (*sliverpb.CurrentTokenOwner, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.CurrentTokenOwner)
	err := c.cc.Invoke(ctx, SliverRPC_CurrentTokenOwner_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Services(ctx context.Context, in *sliverpb.ServicesReq, opts ...grpc.CallOption) (*sliverpb.Services, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Services)
	err := c.cc.Invoke(ctx, SliverRPC_Services_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ServiceDetail(ctx context.Context, in *sliverpb.ServiceDetailReq, opts ...grpc.CallOption) (*sliverpb.ServiceDetail, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ServiceDetail)
	err := c.cc.Invoke(ctx, SliverRPC_ServiceDetail_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartServiceByName(ctx context.Context, in *sliverpb.StartServiceByNameReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ServiceInfo)
	err := c.cc.Invoke(ctx, SliverRPC_StartServiceByName_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) PivotStartListener(ctx context.Context, in *sliverpb.PivotStartListenerReq, opts ...grpc.CallOption) (*sliverpb.PivotListener, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.PivotListener)
	err := c.cc.Invoke(ctx, SliverRPC_PivotStartListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) PivotStopListener(ctx context.Context, in *sliverpb.PivotStopListenerReq, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_PivotStopListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) PivotSessionListeners(ctx context.Context, in *sliverpb.PivotListenersReq, opts ...grpc.CallOption) (*sliverpb.PivotListeners, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.PivotListeners)
	err := c.cc.Invoke(ctx, SliverRPC_PivotSessionListeners_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) PivotGraph(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*clientpb.PivotGraph, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.PivotGraph)
	err := c.cc.Invoke(ctx, SliverRPC_PivotGraph_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartService(ctx context.Context, in *sliverpb.StartServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ServiceInfo)
	err := c.cc.Invoke(ctx, SliverRPC_StartService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StopService(ctx context.Context, in *sliverpb.StopServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ServiceInfo)
	err := c.cc.Invoke(ctx, SliverRPC_StopService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RemoveService(ctx context.Context, in *sliverpb.RemoveServiceReq, opts ...grpc.CallOption) (*sliverpb.ServiceInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ServiceInfo)
	err := c.cc.Invoke(ctx, SliverRPC_RemoveService_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) MakeToken(ctx context.Context, in *sliverpb.MakeTokenReq, opts ...grpc.CallOption) (*sliverpb.MakeToken, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.MakeToken)
	err := c.cc.Invoke(ctx, SliverRPC_MakeToken_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetEnv(ctx context.Context, in *sliverpb.EnvReq, opts ...grpc.CallOption) (*sliverpb.EnvInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.EnvInfo)
	err := c.cc.Invoke(ctx, SliverRPC_GetEnv_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) SetEnv(ctx context.Context, in *sliverpb.SetEnvReq, opts ...grpc.CallOption) (*sliverpb.SetEnv, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.SetEnv)
	err := c.cc.Invoke(ctx, SliverRPC_SetEnv_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) UnsetEnv(ctx context.Context, in *sliverpb.UnsetEnvReq, opts ...grpc.CallOption) (*sliverpb.UnsetEnv, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.UnsetEnv)
	err := c.cc.Invoke(ctx, SliverRPC_UnsetEnv_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Backdoor(ctx context.Context, in *clientpb.BackdoorReq, opts ...grpc.CallOption) (*clientpb.Backdoor, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.Backdoor)
	err := c.cc.Invoke(ctx, SliverRPC_Backdoor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryRead(ctx context.Context, in *sliverpb.RegistryReadReq, opts ...grpc.CallOption) (*sliverpb.RegistryRead, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryRead)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryRead_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryWrite(ctx context.Context, in *sliverpb.RegistryWriteReq, opts ...grpc.CallOption) (*sliverpb.RegistryWrite, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryWrite)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryWrite_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryCreateKey(ctx context.Context, in *sliverpb.RegistryCreateKeyReq, opts ...grpc.CallOption) (*sliverpb.RegistryCreateKey, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryCreateKey)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryCreateKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryDeleteKey(ctx context.Context, in *sliverpb.RegistryDeleteKeyReq, opts ...grpc.CallOption) (*sliverpb.RegistryDeleteKey, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryDeleteKey)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryDeleteKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryListSubKeys(ctx context.Context, in *sliverpb.RegistrySubKeyListReq, opts ...grpc.CallOption) (*sliverpb.RegistrySubKeyList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistrySubKeyList)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryListSubKeys_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryListValues(ctx context.Context, in *sliverpb.RegistryListValuesReq, opts ...grpc.CallOption) (*sliverpb.RegistryValuesList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryValuesList)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryListValues_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegistryReadHive(ctx context.Context, in *sliverpb.RegistryReadHiveReq, opts ...grpc.CallOption) (*sliverpb.RegistryReadHive, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegistryReadHive)
	err := c.cc.Invoke(ctx, SliverRPC_RegistryReadHive_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RunSSHCommand(ctx context.Context, in *sliverpb.SSHCommandReq, opts ...grpc.CallOption) (*sliverpb.SSHCommand, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.SSHCommand)
	err := c.cc.Invoke(ctx, SliverRPC_RunSSHCommand_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) HijackDLL(ctx context.Context, in *clientpb.DllHijackReq, opts ...grpc.CallOption) (*clientpb.DllHijack, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(clientpb.DllHijack)
	err := c.cc.Invoke(ctx, SliverRPC_HijackDLL_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetPrivs(ctx context.Context, in *sliverpb.GetPrivsReq, opts ...grpc.CallOption) (*sliverpb.GetPrivs, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.GetPrivs)
	err := c.cc.Invoke(ctx, SliverRPC_GetPrivs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StartRportFwdListener(ctx context.Context, in *sliverpb.RportFwdStartListenerReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListener, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RportFwdListener)
	err := c.cc.Invoke(ctx, SliverRPC_StartRportFwdListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) GetRportFwdListeners(ctx context.Context, in *sliverpb.RportFwdListenersReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListeners, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RportFwdListeners)
	err := c.cc.Invoke(ctx, SliverRPC_GetRportFwdListeners_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) StopRportFwdListener(ctx context.Context, in *sliverpb.RportFwdStopListenerReq, opts ...grpc.CallOption) (*sliverpb.RportFwdListener, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RportFwdListener)
	err := c.cc.Invoke(ctx, SliverRPC_StopRportFwdListener_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) OpenSession(ctx context.Context, in *sliverpb.OpenSession, opts ...grpc.CallOption) (*sliverpb.OpenSession, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.OpenSession)
	err := c.cc.Invoke(ctx, SliverRPC_OpenSession_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CloseSession(ctx context.Context, in *sliverpb.CloseSession, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CloseSession_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegisterExtension(ctx context.Context, in *sliverpb.RegisterExtensionReq, opts ...grpc.CallOption) (*sliverpb.RegisterExtension, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegisterExtension)
	err := c.cc.Invoke(ctx, SliverRPC_RegisterExtension_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CallExtension(ctx context.Context, in *sliverpb.CallExtensionReq, opts ...grpc.CallOption) (*sliverpb.CallExtension, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.CallExtension)
	err := c.cc.Invoke(ctx, SliverRPC_CallExtension_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ListExtensions(ctx context.Context, in *sliverpb.ListExtensionsReq, opts ...grpc.CallOption) (*sliverpb.ListExtensions, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ListExtensions)
	err := c.cc.Invoke(ctx, SliverRPC_ListExtensions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) RegisterWasmExtension(ctx context.Context, in *sliverpb.RegisterWasmExtensionReq, opts ...grpc.CallOption) (*sliverpb.RegisterWasmExtension, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.RegisterWasmExtension)
	err := c.cc.Invoke(ctx, SliverRPC_RegisterWasmExtension_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ListWasmExtensions(ctx context.Context, in *sliverpb.ListWasmExtensionsReq, opts ...grpc.CallOption) (*sliverpb.ListWasmExtensions, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ListWasmExtensions)
	err := c.cc.Invoke(ctx, SliverRPC_ListWasmExtensions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) ExecWasmExtension(ctx context.Context, in *sliverpb.ExecWasmExtensionReq, opts ...grpc.CallOption) (*sliverpb.ExecWasmExtension, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.ExecWasmExtension)
	err := c.cc.Invoke(ctx, SliverRPC_ExecWasmExtension_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGStartPortForward(ctx context.Context, in *sliverpb.WGPortForwardStartReq, opts ...grpc.CallOption) (*sliverpb.WGPortForward, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGPortForward)
	err := c.cc.Invoke(ctx, SliverRPC_WGStartPortForward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGStopPortForward(ctx context.Context, in *sliverpb.WGPortForwardStopReq, opts ...grpc.CallOption) (*sliverpb.WGPortForward, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGPortForward)
	err := c.cc.Invoke(ctx, SliverRPC_WGStopPortForward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGStartSocks(ctx context.Context, in *sliverpb.WGSocksStartReq, opts ...grpc.CallOption) (*sliverpb.WGSocks, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGSocks)
	err := c.cc.Invoke(ctx, SliverRPC_WGStartSocks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGStopSocks(ctx context.Context, in *sliverpb.WGSocksStopReq, opts ...grpc.CallOption) (*sliverpb.WGSocks, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGSocks)
	err := c.cc.Invoke(ctx, SliverRPC_WGStopSocks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGListForwarders(ctx context.Context, in *sliverpb.WGTCPForwardersReq, opts ...grpc.CallOption) (*sliverpb.WGTCPForwarders, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGTCPForwarders)
	err := c.cc.Invoke(ctx, SliverRPC_WGListForwarders_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) WGListSocksServers(ctx context.Context, in *sliverpb.WGSocksServersReq, opts ...grpc.CallOption) (*sliverpb.WGSocksServers, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.WGSocksServers)
	err := c.cc.Invoke(ctx, SliverRPC_WGListSocksServers_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Shell(ctx context.Context, in *sliverpb.ShellReq, opts ...grpc.CallOption) (*sliverpb.Shell, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Shell)
	err := c.cc.Invoke(ctx, SliverRPC_Shell_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) Portfwd(ctx context.Context, in *sliverpb.PortfwdReq, opts ...grpc.CallOption) (*sliverpb.Portfwd, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Portfwd)
	err := c.cc.Invoke(ctx, SliverRPC_Portfwd_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CreateSocks(ctx context.Context, in *sliverpb.Socks, opts ...grpc.CallOption) (*sliverpb.Socks, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Socks)
	err := c.cc.Invoke(ctx, SliverRPC_CreateSocks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CloseSocks(ctx context.Context, in *sliverpb.Socks, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CloseSocks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) SocksProxy(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[sliverpb.SocksData, sliverpb.SocksData], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[3], SliverRPC_SocksProxy_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[sliverpb.SocksData, sliverpb.SocksData]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_SocksProxyClient = grpc.BidiStreamingClient[sliverpb.SocksData, sliverpb.SocksData]

func (c *sliverRPCClient) CreateTunnel(ctx context.Context, in *sliverpb.Tunnel, opts ...grpc.CallOption) (*sliverpb.Tunnel, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(sliverpb.Tunnel)
	err := c.cc.Invoke(ctx, SliverRPC_CreateTunnel_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) CloseTunnel(ctx context.Context, in *sliverpb.Tunnel, opts ...grpc.CallOption) (*commonpb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(commonpb.Empty)
	err := c.cc.Invoke(ctx, SliverRPC_CloseTunnel_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sliverRPCClient) TunnelData(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[sliverpb.TunnelData, sliverpb.TunnelData], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[4], SliverRPC_TunnelData_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[sliverpb.TunnelData, sliverpb.TunnelData]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_TunnelDataClient = grpc.BidiStreamingClient[sliverpb.TunnelData, sliverpb.TunnelData]

func (c *sliverRPCClient) Events(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[clientpb.Event], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &SliverRPC_ServiceDesc.Streams[5], SliverRPC_Events_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[commonpb.Empty, clientpb.Event]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_EventsClient = grpc.ServerStreamingClient[clientpb.Event]

// SliverRPCServer is the server API for SliverRPC service.
// All implementations must embed UnimplementedSliverRPCServer
// for forward compatibility.
type SliverRPCServer interface {
	// *** Version ***
	GetVersion(context.Context, *commonpb.Empty) (*clientpb.Version, error)
	// *** Client Logs ***
	ClientLog(grpc.ClientStreamingServer[clientpb.ClientLogData, commonpb.Empty]) error
	// *** Operator Commands ***
	GetOperators(context.Context, *commonpb.Empty) (*clientpb.Operators, error)
	// *** Generic ***
	Kill(context.Context, *sliverpb.KillReq) (*commonpb.Empty, error)
	Reconfigure(context.Context, *sliverpb.ReconfigureReq) (*sliverpb.Reconfigure, error)
	Rename(context.Context, *clientpb.RenameReq) (*commonpb.Empty, error)
	// *** Sessions ***
	GetSessions(context.Context, *commonpb.Empty) (*clientpb.Sessions, error)
	// ***Threat monitoring ***
	MonitorStart(context.Context, *commonpb.Empty) (*commonpb.Response, error)
	MonitorStop(context.Context, *commonpb.Empty) (*commonpb.Empty, error)
	MonitorListConfig(context.Context, *commonpb.Empty) (*clientpb.MonitoringProviders, error)
	MonitorAddConfig(context.Context, *clientpb.MonitoringProvider) (*commonpb.Response, error)
	MonitorDelConfig(context.Context, *clientpb.MonitoringProvider) (*commonpb.Response, error)
	// *** Listeners ***
	StartMTLSListener(context.Context, *clientpb.MTLSListenerReq) (*clientpb.ListenerJob, error)
	StartWGListener(context.Context, *clientpb.WGListenerReq) (*clientpb.ListenerJob, error)
	StartDNSListener(context.Context, *clientpb.DNSListenerReq) (*clientpb.ListenerJob, error)
	StartHTTPSListener(context.Context, *clientpb.HTTPListenerReq) (*clientpb.ListenerJob, error)
	StartHTTPListener(context.Context, *clientpb.HTTPListenerReq) (*clientpb.ListenerJob, error)
	// *** Beacons ***
	GetBeacons(context.Context, *commonpb.Empty) (*clientpb.Beacons, error)
	GetBeacon(context.Context, *clientpb.Beacon) (*clientpb.Beacon, error)
	RmBeacon(context.Context, *clientpb.Beacon) (*commonpb.Empty, error)
	GetBeaconTasks(context.Context, *clientpb.Beacon) (*clientpb.BeaconTasks, error)
	GetBeaconTaskContent(context.Context, *clientpb.BeaconTask) (*clientpb.BeaconTask, error)
	CancelBeaconTask(context.Context, *clientpb.BeaconTask) (*clientpb.BeaconTask, error)
	UpdateBeaconIntegrityInformation(context.Context, *clientpb.BeaconIntegrity) (*commonpb.Empty, error)
	// *** Jobs ***
	GetJobs(context.Context, *commonpb.Empty) (*clientpb.Jobs, error)
	KillJob(context.Context, *clientpb.KillJobReq) (*clientpb.KillJob, error)
	RestartJobs(context.Context, *clientpb.RestartJobReq) (*commonpb.Empty, error)
	// *** Stager Listener ***
	StartTCPStagerListener(context.Context, *clientpb.StagerListenerReq) (*clientpb.StagerListener, error)
	// *** Loot ***
	LootAdd(context.Context, *clientpb.Loot) (*clientpb.Loot, error)
	LootRm(context.Context, *clientpb.Loot) (*commonpb.Empty, error)
	LootUpdate(context.Context, *clientpb.Loot) (*clientpb.Loot, error)
	LootContent(context.Context, *clientpb.Loot) (*clientpb.Loot, error)
	LootAll(context.Context, *commonpb.Empty) (*clientpb.AllLoot, error)
	// *** Creds ***
	Creds(context.Context, *commonpb.Empty) (*clientpb.Credentials, error)
	CredsAdd(context.Context, *clientpb.Credentials) (*commonpb.Empty, error)
	CredsRm(context.Context, *clientpb.Credentials) (*commonpb.Empty, error)
	CredsUpdate(context.Context, *clientpb.Credentials) (*commonpb.Empty, error)
	GetCredByID(context.Context, *clientpb.Credential) (*clientpb.Credential, error)
	GetCredsByHashType(context.Context, *clientpb.Credential) (*clientpb.Credentials, error)
	GetPlaintextCredsByHashType(context.Context, *clientpb.Credential) (*clientpb.Credentials, error)
	CredsSniffHashType(context.Context, *clientpb.Credential) (*clientpb.Credential, error)
	// *** Hosts ***
	Hosts(context.Context, *commonpb.Empty) (*clientpb.AllHosts, error)
	Host(context.Context, *clientpb.Host) (*clientpb.Host, error)
	HostRm(context.Context, *clientpb.Host) (*commonpb.Empty, error)
	HostIOCRm(context.Context, *clientpb.IOC) (*commonpb.Empty, error)
	// *** Implants ***
	Generate(context.Context, *clientpb.GenerateReq) (*clientpb.Generate, error)
	GenerateExternal(context.Context, *clientpb.ExternalGenerateReq) (*clientpb.ExternalImplantConfig, error)
	GenerateExternalSaveBuild(context.Context, *clientpb.ExternalImplantBinary) (*commonpb.Empty, error)
	GenerateExternalGetBuildConfig(context.Context, *clientpb.ImplantBuild) (*clientpb.ExternalImplantConfig, error)
	GenerateStage(context.Context, *clientpb.GenerateStageReq) (*clientpb.Generate, error)
	StageImplantBuild(context.Context, *clientpb.ImplantStageReq) (*commonpb.Empty, error)
	// *** HTTP C2 Profiles ***
	GetHTTPC2Profiles(context.Context, *commonpb.Empty) (*clientpb.HTTPC2Configs, error)
	GetHTTPC2ProfileByName(context.Context, *clientpb.C2ProfileReq) (*clientpb.HTTPC2Config, error)
	SaveHTTPC2Profile(context.Context, *clientpb.HTTPC2ConfigReq) (*commonpb.Empty, error)
	// *** Builders ***
	BuilderRegister(*clientpb.Builder, grpc.ServerStreamingServer[clientpb.Event]) error
	BuilderTrigger(context.Context, *clientpb.Event) (*commonpb.Empty, error)
	Builders(context.Context, *commonpb.Empty) (*clientpb.Builders, error)
	// *** Certificates ***
	GetCertificateInfo(context.Context, *clientpb.CertificatesReq) (*clientpb.CertificateInfo, error)
	// *** Crackstation ***
	CrackstationRegister(*clientpb.Crackstation, grpc.ServerStreamingServer[clientpb.Event]) error
	CrackstationTrigger(context.Context, *clientpb.Event) (*commonpb.Empty, error)
	CrackstationBenchmark(context.Context, *clientpb.CrackBenchmark) (*commonpb.Empty, error)
	Crackstations(context.Context, *commonpb.Empty) (*clientpb.Crackstations, error)
	CrackTaskByID(context.Context, *clientpb.CrackTask) (*clientpb.CrackTask, error)
	CrackTaskUpdate(context.Context, *clientpb.CrackTask) (*commonpb.Empty, error)
	CrackFilesList(context.Context, *clientpb.CrackFile) (*clientpb.CrackFiles, error)
	CrackFileCreate(context.Context, *clientpb.CrackFile) (*clientpb.CrackFile, error)
	CrackFileChunkUpload(context.Context, *clientpb.CrackFileChunk) (*commonpb.Empty, error)
	CrackFileChunkDownload(context.Context, *clientpb.CrackFileChunk) (*clientpb.CrackFileChunk, error)
	CrackFileComplete(context.Context, *clientpb.CrackFile) (*commonpb.Empty, error)
	CrackFileDelete(context.Context, *clientpb.CrackFile) (*commonpb.Empty, error)
	// *** Payloads ***
	Regenerate(context.Context, *clientpb.RegenerateReq) (*clientpb.Generate, error)
	ImplantBuilds(context.Context, *commonpb.Empty) (*clientpb.ImplantBuilds, error)
	DeleteImplantBuild(context.Context, *clientpb.DeleteReq) (*commonpb.Empty, error)
	Canaries(context.Context, *commonpb.Empty) (*clientpb.Canaries, error)
	GenerateWGClientConfig(context.Context, *commonpb.Empty) (*clientpb.WGClientConfig, error)
	GenerateUniqueIP(context.Context, *commonpb.Empty) (*clientpb.UniqueWGIP, error)
	ImplantProfiles(context.Context, *commonpb.Empty) (*clientpb.ImplantProfiles, error)
	DeleteImplantProfile(context.Context, *clientpb.DeleteReq) (*commonpb.Empty, error)
	SaveImplantProfile(context.Context, *clientpb.ImplantProfile) (*clientpb.ImplantProfile, error)
	ShellcodeRDI(context.Context, *clientpb.ShellcodeRDIReq) (*clientpb.ShellcodeRDI, error)
	GetCompiler(context.Context, *commonpb.Empty) (*clientpb.Compiler, error)
	ShellcodeEncoder(context.Context, *clientpb.ShellcodeEncodeReq) (*clientpb.ShellcodeEncode, error)
	ShellcodeEncoderMap(context.Context, *commonpb.Empty) (*clientpb.ShellcodeEncoderMap, error)
	TrafficEncoderMap(context.Context, *commonpb.Empty) (*clientpb.TrafficEncoderMap, error)
	TrafficEncoderAdd(context.Context, *clientpb.TrafficEncoder) (*clientpb.TrafficEncoderTests, error)
	TrafficEncoderRm(context.Context, *clientpb.TrafficEncoder) (*commonpb.Empty, error)
	// *** Websites ***
	Websites(context.Context, *commonpb.Empty) (*clientpb.Websites, error)
	Website(context.Context, *clientpb.Website) (*clientpb.Website, error)
	WebsiteRemove(context.Context, *clientpb.Website) (*commonpb.Empty, error)
	WebsiteAddContent(context.Context, *clientpb.WebsiteAddContent) (*clientpb.Website, error)
	WebsiteUpdateContent(context.Context, *clientpb.WebsiteAddContent) (*clientpb.Website, error)
	WebsiteRemoveContent(context.Context, *clientpb.WebsiteRemoveContent) (*clientpb.Website, error)
	// *** Session Interactions ***
	Ping(context.Context, *sliverpb.Ping) (*sliverpb.Ping, error)
	Ps(context.Context, *sliverpb.PsReq) (*sliverpb.Ps, error)
	Terminate(context.Context, *sliverpb.TerminateReq) (*sliverpb.Terminate, error)
	Ifconfig(context.Context, *sliverpb.IfconfigReq) (*sliverpb.Ifconfig, error)
	Netstat(context.Context, *sliverpb.NetstatReq) (*sliverpb.Netstat, error)
	Ls(context.Context, *sliverpb.LsReq) (*sliverpb.Ls, error)
	Cd(context.Context, *sliverpb.CdReq) (*sliverpb.Pwd, error)
	Pwd(context.Context, *sliverpb.PwdReq) (*sliverpb.Pwd, error)
	Mv(context.Context, *sliverpb.MvReq) (*sliverpb.Mv, error)
	Cp(context.Context, *sliverpb.CpReq) (*sliverpb.Cp, error)
	Rm(context.Context, *sliverpb.RmReq) (*sliverpb.Rm, error)
	Mkdir(context.Context, *sliverpb.MkdirReq) (*sliverpb.Mkdir, error)
	Download(context.Context, *sliverpb.DownloadReq) (*sliverpb.Download, error)
	Upload(context.Context, *sliverpb.UploadReq) (*sliverpb.Upload, error)
	Grep(context.Context, *sliverpb.GrepReq) (*sliverpb.Grep, error)
	Chmod(context.Context, *sliverpb.ChmodReq) (*sliverpb.Chmod, error)
	Chown(context.Context, *sliverpb.ChownReq) (*sliverpb.Chown, error)
	Chtimes(context.Context, *sliverpb.ChtimesReq) (*sliverpb.Chtimes, error)
	MemfilesList(context.Context, *sliverpb.MemfilesListReq) (*sliverpb.Ls, error)
	MemfilesAdd(context.Context, *sliverpb.MemfilesAddReq) (*sliverpb.MemfilesAdd, error)
	MemfilesRm(context.Context, *sliverpb.MemfilesRmReq) (*sliverpb.MemfilesRm, error)
	Mount(context.Context, *sliverpb.MountReq) (*sliverpb.Mount, error)
	ProcessDump(context.Context, *sliverpb.ProcessDumpReq) (*sliverpb.ProcessDump, error)
	RunAs(context.Context, *sliverpb.RunAsReq) (*sliverpb.RunAs, error)
	Impersonate(context.Context, *sliverpb.ImpersonateReq) (*sliverpb.Impersonate, error)
	RevToSelf(context.Context, *sliverpb.RevToSelfReq) (*sliverpb.RevToSelf, error)
	GetSystem(context.Context, *clientpb.GetSystemReq) (*sliverpb.GetSystem, error)
	Task(context.Context, *sliverpb.TaskReq) (*sliverpb.Task, error)
	Msf(context.Context, *clientpb.MSFReq) (*sliverpb.Task, error)
	MsfRemote(context.Context, *clientpb.MSFRemoteReq) (*sliverpb.Task, error)
	ExecuteAssembly(context.Context, *sliverpb.ExecuteAssemblyReq) (*sliverpb.ExecuteAssembly, error)
	Migrate(context.Context, *clientpb.MigrateReq) (*sliverpb.Migrate, error)
	Execute(context.Context, *sliverpb.ExecuteReq) (*sliverpb.Execute, error)
	ExecuteWindows(context.Context, *sliverpb.ExecuteWindowsReq) (*sliverpb.Execute, error)
	Sideload(context.Context, *sliverpb.SideloadReq) (*sliverpb.Sideload, error)
	SpawnDll(context.Context, *sliverpb.InvokeSpawnDllReq) (*sliverpb.SpawnDll, error)
	Screenshot(context.Context, *sliverpb.ScreenshotReq) (*sliverpb.Screenshot, error)
	CurrentTokenOwner(context.Context, *sliverpb.CurrentTokenOwnerReq) (*sliverpb.CurrentTokenOwner, error)
	Services(context.Context, *sliverpb.ServicesReq) (*sliverpb.Services, error)
	ServiceDetail(context.Context, *sliverpb.ServiceDetailReq) (*sliverpb.ServiceDetail, error)
	StartServiceByName(context.Context, *sliverpb.StartServiceByNameReq) (*sliverpb.ServiceInfo, error)
	// *** Pivots ***
	PivotStartListener(context.Context, *sliverpb.PivotStartListenerReq) (*sliverpb.PivotListener, error)
	PivotStopListener(context.Context, *sliverpb.PivotStopListenerReq) (*commonpb.Empty, error)
	PivotSessionListeners(context.Context, *sliverpb.PivotListenersReq) (*sliverpb.PivotListeners, error)
	PivotGraph(context.Context, *commonpb.Empty) (*clientpb.PivotGraph, error)
	StartService(context.Context, *sliverpb.StartServiceReq) (*sliverpb.ServiceInfo, error)
	StopService(context.Context, *sliverpb.StopServiceReq) (*sliverpb.ServiceInfo, error)
	RemoveService(context.Context, *sliverpb.RemoveServiceReq) (*sliverpb.ServiceInfo, error)
	MakeToken(context.Context, *sliverpb.MakeTokenReq) (*sliverpb.MakeToken, error)
	GetEnv(context.Context, *sliverpb.EnvReq) (*sliverpb.EnvInfo, error)
	SetEnv(context.Context, *sliverpb.SetEnvReq) (*sliverpb.SetEnv, error)
	UnsetEnv(context.Context, *sliverpb.UnsetEnvReq) (*sliverpb.UnsetEnv, error)
	Backdoor(context.Context, *clientpb.BackdoorReq) (*clientpb.Backdoor, error)
	RegistryRead(context.Context, *sliverpb.RegistryReadReq) (*sliverpb.RegistryRead, error)
	RegistryWrite(context.Context, *sliverpb.RegistryWriteReq) (*sliverpb.RegistryWrite, error)
	RegistryCreateKey(context.Context, *sliverpb.RegistryCreateKeyReq) (*sliverpb.RegistryCreateKey, error)
	RegistryDeleteKey(context.Context, *sliverpb.RegistryDeleteKeyReq) (*sliverpb.RegistryDeleteKey, error)
	RegistryListSubKeys(context.Context, *sliverpb.RegistrySubKeyListReq) (*sliverpb.RegistrySubKeyList, error)
	RegistryListValues(context.Context, *sliverpb.RegistryListValuesReq) (*sliverpb.RegistryValuesList, error)
	RegistryReadHive(context.Context, *sliverpb.RegistryReadHiveReq) (*sliverpb.RegistryReadHive, error)
	RunSSHCommand(context.Context, *sliverpb.SSHCommandReq) (*sliverpb.SSHCommand, error)
	HijackDLL(context.Context, *clientpb.DllHijackReq) (*clientpb.DllHijack, error)
	GetPrivs(context.Context, *sliverpb.GetPrivsReq) (*sliverpb.GetPrivs, error)
	StartRportFwdListener(context.Context, *sliverpb.RportFwdStartListenerReq) (*sliverpb.RportFwdListener, error)
	GetRportFwdListeners(context.Context, *sliverpb.RportFwdListenersReq) (*sliverpb.RportFwdListeners, error)
	StopRportFwdListener(context.Context, *sliverpb.RportFwdStopListenerReq) (*sliverpb.RportFwdListener, error)
	// *** Beacon *** -only commands
	OpenSession(context.Context, *sliverpb.OpenSession) (*sliverpb.OpenSession, error)
	CloseSession(context.Context, *sliverpb.CloseSession) (*commonpb.Empty, error)
	// *** Extensions ***
	RegisterExtension(context.Context, *sliverpb.RegisterExtensionReq) (*sliverpb.RegisterExtension, error)
	CallExtension(context.Context, *sliverpb.CallExtensionReq) (*sliverpb.CallExtension, error)
	ListExtensions(context.Context, *sliverpb.ListExtensionsReq) (*sliverpb.ListExtensions, error)
	// *** Wasm Extensions ***
	RegisterWasmExtension(context.Context, *sliverpb.RegisterWasmExtensionReq) (*sliverpb.RegisterWasmExtension, error)
	ListWasmExtensions(context.Context, *sliverpb.ListWasmExtensionsReq) (*sliverpb.ListWasmExtensions, error)
	ExecWasmExtension(context.Context, *sliverpb.ExecWasmExtensionReq) (*sliverpb.ExecWasmExtension, error)
	// *** Wireguard Specific ***
	WGStartPortForward(context.Context, *sliverpb.WGPortForwardStartReq) (*sliverpb.WGPortForward, error)
	WGStopPortForward(context.Context, *sliverpb.WGPortForwardStopReq) (*sliverpb.WGPortForward, error)
	WGStartSocks(context.Context, *sliverpb.WGSocksStartReq) (*sliverpb.WGSocks, error)
	WGStopSocks(context.Context, *sliverpb.WGSocksStopReq) (*sliverpb.WGSocks, error)
	WGListForwarders(context.Context, *sliverpb.WGTCPForwardersReq) (*sliverpb.WGTCPForwarders, error)
	WGListSocksServers(context.Context, *sliverpb.WGSocksServersReq) (*sliverpb.WGSocksServers, error)
	// *** Realtime Commands ***
	Shell(context.Context, *sliverpb.ShellReq) (*sliverpb.Shell, error)
	Portfwd(context.Context, *sliverpb.PortfwdReq) (*sliverpb.Portfwd, error)
	// *** Socks5 ***
	CreateSocks(context.Context, *sliverpb.Socks) (*sliverpb.Socks, error)
	CloseSocks(context.Context, *sliverpb.Socks) (*commonpb.Empty, error)
	SocksProxy(grpc.BidiStreamingServer[sliverpb.SocksData, sliverpb.SocksData]) error
	// *** Tunnels ***
	CreateTunnel(context.Context, *sliverpb.Tunnel) (*sliverpb.Tunnel, error)
	CloseTunnel(context.Context, *sliverpb.Tunnel) (*commonpb.Empty, error)
	TunnelData(grpc.BidiStreamingServer[sliverpb.TunnelData, sliverpb.TunnelData]) error
	// *** Events ***
	Events(*commonpb.Empty, grpc.ServerStreamingServer[clientpb.Event]) error
	mustEmbedUnimplementedSliverRPCServer()
}

// UnimplementedSliverRPCServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedSliverRPCServer struct{}

func (UnimplementedSliverRPCServer) GetVersion(context.Context, *commonpb.Empty) (*clientpb.Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
}
func (UnimplementedSliverRPCServer) ClientLog(grpc.ClientStreamingServer[clientpb.ClientLogData, commonpb.Empty]) error {
	return status.Errorf(codes.Unimplemented, "method ClientLog not implemented")
}
func (UnimplementedSliverRPCServer) GetOperators(context.Context, *commonpb.Empty) (*clientpb.Operators, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOperators not implemented")
}
func (UnimplementedSliverRPCServer) Kill(context.Context, *sliverpb.KillReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Kill not implemented")
}
func (UnimplementedSliverRPCServer) Reconfigure(context.Context, *sliverpb.ReconfigureReq) (*sliverpb.Reconfigure, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Reconfigure not implemented")
}
func (UnimplementedSliverRPCServer) Rename(context.Context, *clientpb.RenameReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rename not implemented")
}
func (UnimplementedSliverRPCServer) GetSessions(context.Context, *commonpb.Empty) (*clientpb.Sessions, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSessions not implemented")
}
func (UnimplementedSliverRPCServer) MonitorStart(context.Context, *commonpb.Empty) (*commonpb.Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MonitorStart not implemented")
}
func (UnimplementedSliverRPCServer) MonitorStop(context.Context, *commonpb.Empty) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MonitorStop not implemented")
}
func (UnimplementedSliverRPCServer) MonitorListConfig(context.Context, *commonpb.Empty) (*clientpb.MonitoringProviders, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MonitorListConfig not implemented")
}
func (UnimplementedSliverRPCServer) MonitorAddConfig(context.Context, *clientpb.MonitoringProvider) (*commonpb.Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MonitorAddConfig not implemented")
}
func (UnimplementedSliverRPCServer) MonitorDelConfig(context.Context, *clientpb.MonitoringProvider) (*commonpb.Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MonitorDelConfig not implemented")
}
func (UnimplementedSliverRPCServer) StartMTLSListener(context.Context, *clientpb.MTLSListenerReq) (*clientpb.ListenerJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartMTLSListener not implemented")
}
func (UnimplementedSliverRPCServer) StartWGListener(context.Context, *clientpb.WGListenerReq) (*clientpb.ListenerJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartWGListener not implemented")
}
func (UnimplementedSliverRPCServer) StartDNSListener(context.Context, *clientpb.DNSListenerReq) (*clientpb.ListenerJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartDNSListener not implemented")
}
func (UnimplementedSliverRPCServer) StartHTTPSListener(context.Context, *clientpb.HTTPListenerReq) (*clientpb.ListenerJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartHTTPSListener not implemented")
}
func (UnimplementedSliverRPCServer) StartHTTPListener(context.Context, *clientpb.HTTPListenerReq) (*clientpb.ListenerJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartHTTPListener not implemented")
}
func (UnimplementedSliverRPCServer) GetBeacons(context.Context, *commonpb.Empty) (*clientpb.Beacons, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBeacons not implemented")
}
func (UnimplementedSliverRPCServer) GetBeacon(context.Context, *clientpb.Beacon) (*clientpb.Beacon, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBeacon not implemented")
}
func (UnimplementedSliverRPCServer) RmBeacon(context.Context, *clientpb.Beacon) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RmBeacon not implemented")
}
func (UnimplementedSliverRPCServer) GetBeaconTasks(context.Context, *clientpb.Beacon) (*clientpb.BeaconTasks, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBeaconTasks not implemented")
}
func (UnimplementedSliverRPCServer) GetBeaconTaskContent(context.Context, *clientpb.BeaconTask) (*clientpb.BeaconTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBeaconTaskContent not implemented")
}
func (UnimplementedSliverRPCServer) CancelBeaconTask(context.Context, *clientpb.BeaconTask) (*clientpb.BeaconTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelBeaconTask not implemented")
}
func (UnimplementedSliverRPCServer) UpdateBeaconIntegrityInformation(context.Context, *clientpb.BeaconIntegrity) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateBeaconIntegrityInformation not implemented")
}
func (UnimplementedSliverRPCServer) GetJobs(context.Context, *commonpb.Empty) (*clientpb.Jobs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobs not implemented")
}
func (UnimplementedSliverRPCServer) KillJob(context.Context, *clientpb.KillJobReq) (*clientpb.KillJob, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KillJob not implemented")
}
func (UnimplementedSliverRPCServer) RestartJobs(context.Context, *clientpb.RestartJobReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartJobs not implemented")
}
func (UnimplementedSliverRPCServer) StartTCPStagerListener(context.Context, *clientpb.StagerListenerReq) (*clientpb.StagerListener, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartTCPStagerListener not implemented")
}
func (UnimplementedSliverRPCServer) LootAdd(context.Context, *clientpb.Loot) (*clientpb.Loot, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LootAdd not implemented")
}
func (UnimplementedSliverRPCServer) LootRm(context.Context, *clientpb.Loot) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LootRm not implemented")
}
func (UnimplementedSliverRPCServer) LootUpdate(context.Context, *clientpb.Loot) (*clientpb.Loot, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LootUpdate not implemented")
}
func (UnimplementedSliverRPCServer) LootContent(context.Context, *clientpb.Loot) (*clientpb.Loot, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LootContent not implemented")
}
func (UnimplementedSliverRPCServer) LootAll(context.Context, *commonpb.Empty) (*clientpb.AllLoot, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LootAll not implemented")
}
func (UnimplementedSliverRPCServer) Creds(context.Context, *commonpb.Empty) (*clientpb.Credentials, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Creds not implemented")
}
func (UnimplementedSliverRPCServer) CredsAdd(context.Context, *clientpb.Credentials) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredsAdd not implemented")
}
func (UnimplementedSliverRPCServer) CredsRm(context.Context, *clientpb.Credentials) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredsRm not implemented")
}
func (UnimplementedSliverRPCServer) CredsUpdate(context.Context, *clientpb.Credentials) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredsUpdate not implemented")
}
func (UnimplementedSliverRPCServer) GetCredByID(context.Context, *clientpb.Credential) (*clientpb.Credential, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCredByID not implemented")
}
func (UnimplementedSliverRPCServer) GetCredsByHashType(context.Context, *clientpb.Credential) (*clientpb.Credentials, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCredsByHashType not implemented")
}
func (UnimplementedSliverRPCServer) GetPlaintextCredsByHashType(context.Context, *clientpb.Credential) (*clientpb.Credentials, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPlaintextCredsByHashType not implemented")
}
func (UnimplementedSliverRPCServer) CredsSniffHashType(context.Context, *clientpb.Credential) (*clientpb.Credential, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CredsSniffHashType not implemented")
}
func (UnimplementedSliverRPCServer) Hosts(context.Context, *commonpb.Empty) (*clientpb.AllHosts, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Hosts not implemented")
}
func (UnimplementedSliverRPCServer) Host(context.Context, *clientpb.Host) (*clientpb.Host, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Host not implemented")
}
func (UnimplementedSliverRPCServer) HostRm(context.Context, *clientpb.Host) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HostRm not implemented")
}
func (UnimplementedSliverRPCServer) HostIOCRm(context.Context, *clientpb.IOC) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HostIOCRm not implemented")
}
func (UnimplementedSliverRPCServer) Generate(context.Context, *clientpb.GenerateReq) (*clientpb.Generate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Generate not implemented")
}
func (UnimplementedSliverRPCServer) GenerateExternal(context.Context, *clientpb.ExternalGenerateReq) (*clientpb.ExternalImplantConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateExternal not implemented")
}
func (UnimplementedSliverRPCServer) GenerateExternalSaveBuild(context.Context, *clientpb.ExternalImplantBinary) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateExternalSaveBuild not implemented")
}
func (UnimplementedSliverRPCServer) GenerateExternalGetBuildConfig(context.Context, *clientpb.ImplantBuild) (*clientpb.ExternalImplantConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateExternalGetBuildConfig not implemented")
}
func (UnimplementedSliverRPCServer) GenerateStage(context.Context, *clientpb.GenerateStageReq) (*clientpb.Generate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateStage not implemented")
}
func (UnimplementedSliverRPCServer) StageImplantBuild(context.Context, *clientpb.ImplantStageReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StageImplantBuild not implemented")
}
func (UnimplementedSliverRPCServer) GetHTTPC2Profiles(context.Context, *commonpb.Empty) (*clientpb.HTTPC2Configs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHTTPC2Profiles not implemented")
}
func (UnimplementedSliverRPCServer) GetHTTPC2ProfileByName(context.Context, *clientpb.C2ProfileReq) (*clientpb.HTTPC2Config, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHTTPC2ProfileByName not implemented")
}
func (UnimplementedSliverRPCServer) SaveHTTPC2Profile(context.Context, *clientpb.HTTPC2ConfigReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveHTTPC2Profile not implemented")
}
func (UnimplementedSliverRPCServer) BuilderRegister(*clientpb.Builder, grpc.ServerStreamingServer[clientpb.Event]) error {
	return status.Errorf(codes.Unimplemented, "method BuilderRegister not implemented")
}
func (UnimplementedSliverRPCServer) BuilderTrigger(context.Context, *clientpb.Event) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BuilderTrigger not implemented")
}
func (UnimplementedSliverRPCServer) Builders(context.Context, *commonpb.Empty) (*clientpb.Builders, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Builders not implemented")
}
func (UnimplementedSliverRPCServer) GetCertificateInfo(context.Context, *clientpb.CertificatesReq) (*clientpb.CertificateInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCertificateInfo not implemented")
}
func (UnimplementedSliverRPCServer) CrackstationRegister(*clientpb.Crackstation, grpc.ServerStreamingServer[clientpb.Event]) error {
	return status.Errorf(codes.Unimplemented, "method CrackstationRegister not implemented")
}
func (UnimplementedSliverRPCServer) CrackstationTrigger(context.Context, *clientpb.Event) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackstationTrigger not implemented")
}
func (UnimplementedSliverRPCServer) CrackstationBenchmark(context.Context, *clientpb.CrackBenchmark) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackstationBenchmark not implemented")
}
func (UnimplementedSliverRPCServer) Crackstations(context.Context, *commonpb.Empty) (*clientpb.Crackstations, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Crackstations not implemented")
}
func (UnimplementedSliverRPCServer) CrackTaskByID(context.Context, *clientpb.CrackTask) (*clientpb.CrackTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackTaskByID not implemented")
}
func (UnimplementedSliverRPCServer) CrackTaskUpdate(context.Context, *clientpb.CrackTask) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackTaskUpdate not implemented")
}
func (UnimplementedSliverRPCServer) CrackFilesList(context.Context, *clientpb.CrackFile) (*clientpb.CrackFiles, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFilesList not implemented")
}
func (UnimplementedSliverRPCServer) CrackFileCreate(context.Context, *clientpb.CrackFile) (*clientpb.CrackFile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFileCreate not implemented")
}
func (UnimplementedSliverRPCServer) CrackFileChunkUpload(context.Context, *clientpb.CrackFileChunk) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFileChunkUpload not implemented")
}
func (UnimplementedSliverRPCServer) CrackFileChunkDownload(context.Context, *clientpb.CrackFileChunk) (*clientpb.CrackFileChunk, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFileChunkDownload not implemented")
}
func (UnimplementedSliverRPCServer) CrackFileComplete(context.Context, *clientpb.CrackFile) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFileComplete not implemented")
}
func (UnimplementedSliverRPCServer) CrackFileDelete(context.Context, *clientpb.CrackFile) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CrackFileDelete not implemented")
}
func (UnimplementedSliverRPCServer) Regenerate(context.Context, *clientpb.RegenerateReq) (*clientpb.Generate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Regenerate not implemented")
}
func (UnimplementedSliverRPCServer) ImplantBuilds(context.Context, *commonpb.Empty) (*clientpb.ImplantBuilds, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImplantBuilds not implemented")
}
func (UnimplementedSliverRPCServer) DeleteImplantBuild(context.Context, *clientpb.DeleteReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteImplantBuild not implemented")
}
func (UnimplementedSliverRPCServer) Canaries(context.Context, *commonpb.Empty) (*clientpb.Canaries, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Canaries not implemented")
}
func (UnimplementedSliverRPCServer) GenerateWGClientConfig(context.Context, *commonpb.Empty) (*clientpb.WGClientConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateWGClientConfig not implemented")
}
func (UnimplementedSliverRPCServer) GenerateUniqueIP(context.Context, *commonpb.Empty) (*clientpb.UniqueWGIP, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateUniqueIP not implemented")
}
func (UnimplementedSliverRPCServer) ImplantProfiles(context.Context, *commonpb.Empty) (*clientpb.ImplantProfiles, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImplantProfiles not implemented")
}
func (UnimplementedSliverRPCServer) DeleteImplantProfile(context.Context, *clientpb.DeleteReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteImplantProfile not implemented")
}
func (UnimplementedSliverRPCServer) SaveImplantProfile(context.Context, *clientpb.ImplantProfile) (*clientpb.ImplantProfile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveImplantProfile not implemented")
}
func (UnimplementedSliverRPCServer) ShellcodeRDI(context.Context, *clientpb.ShellcodeRDIReq) (*clientpb.ShellcodeRDI, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShellcodeRDI not implemented")
}
func (UnimplementedSliverRPCServer) GetCompiler(context.Context, *commonpb.Empty) (*clientpb.Compiler, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompiler not implemented")
}
func (UnimplementedSliverRPCServer) ShellcodeEncoder(context.Context, *clientpb.ShellcodeEncodeReq) (*clientpb.ShellcodeEncode, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShellcodeEncoder not implemented")
}
func (UnimplementedSliverRPCServer) ShellcodeEncoderMap(context.Context, *commonpb.Empty) (*clientpb.ShellcodeEncoderMap, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShellcodeEncoderMap not implemented")
}
func (UnimplementedSliverRPCServer) TrafficEncoderMap(context.Context, *commonpb.Empty) (*clientpb.TrafficEncoderMap, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TrafficEncoderMap not implemented")
}
func (UnimplementedSliverRPCServer) TrafficEncoderAdd(context.Context, *clientpb.TrafficEncoder) (*clientpb.TrafficEncoderTests, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TrafficEncoderAdd not implemented")
}
func (UnimplementedSliverRPCServer) TrafficEncoderRm(context.Context, *clientpb.TrafficEncoder) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TrafficEncoderRm not implemented")
}
func (UnimplementedSliverRPCServer) Websites(context.Context, *commonpb.Empty) (*clientpb.Websites, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Websites not implemented")
}
func (UnimplementedSliverRPCServer) Website(context.Context, *clientpb.Website) (*clientpb.Website, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Website not implemented")
}
func (UnimplementedSliverRPCServer) WebsiteRemove(context.Context, *clientpb.Website) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsiteRemove not implemented")
}
func (UnimplementedSliverRPCServer) WebsiteAddContent(context.Context, *clientpb.WebsiteAddContent) (*clientpb.Website, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsiteAddContent not implemented")
}
func (UnimplementedSliverRPCServer) WebsiteUpdateContent(context.Context, *clientpb.WebsiteAddContent) (*clientpb.Website, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsiteUpdateContent not implemented")
}
func (UnimplementedSliverRPCServer) WebsiteRemoveContent(context.Context, *clientpb.WebsiteRemoveContent) (*clientpb.Website, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WebsiteRemoveContent not implemented")
}
func (UnimplementedSliverRPCServer) Ping(context.Context, *sliverpb.Ping) (*sliverpb.Ping, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedSliverRPCServer) Ps(context.Context, *sliverpb.PsReq) (*sliverpb.Ps, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ps not implemented")
}
func (UnimplementedSliverRPCServer) Terminate(context.Context, *sliverpb.TerminateReq) (*sliverpb.Terminate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Terminate not implemented")
}
func (UnimplementedSliverRPCServer) Ifconfig(context.Context, *sliverpb.IfconfigReq) (*sliverpb.Ifconfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ifconfig not implemented")
}
func (UnimplementedSliverRPCServer) Netstat(context.Context, *sliverpb.NetstatReq) (*sliverpb.Netstat, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Netstat not implemented")
}
func (UnimplementedSliverRPCServer) Ls(context.Context, *sliverpb.LsReq) (*sliverpb.Ls, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ls not implemented")
}
func (UnimplementedSliverRPCServer) Cd(context.Context, *sliverpb.CdReq) (*sliverpb.Pwd, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cd not implemented")
}
func (UnimplementedSliverRPCServer) Pwd(context.Context, *sliverpb.PwdReq) (*sliverpb.Pwd, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Pwd not implemented")
}
func (UnimplementedSliverRPCServer) Mv(context.Context, *sliverpb.MvReq) (*sliverpb.Mv, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mv not implemented")
}
func (UnimplementedSliverRPCServer) Cp(context.Context, *sliverpb.CpReq) (*sliverpb.Cp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cp not implemented")
}
func (UnimplementedSliverRPCServer) Rm(context.Context, *sliverpb.RmReq) (*sliverpb.Rm, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rm not implemented")
}
func (UnimplementedSliverRPCServer) Mkdir(context.Context, *sliverpb.MkdirReq) (*sliverpb.Mkdir, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mkdir not implemented")
}
func (UnimplementedSliverRPCServer) Download(context.Context, *sliverpb.DownloadReq) (*sliverpb.Download, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Download not implemented")
}
func (UnimplementedSliverRPCServer) Upload(context.Context, *sliverpb.UploadReq) (*sliverpb.Upload, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
func (UnimplementedSliverRPCServer) Grep(context.Context, *sliverpb.GrepReq) (*sliverpb.Grep, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Grep not implemented")
}
func (UnimplementedSliverRPCServer) Chmod(context.Context, *sliverpb.ChmodReq) (*sliverpb.Chmod, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Chmod not implemented")
}
func (UnimplementedSliverRPCServer) Chown(context.Context, *sliverpb.ChownReq) (*sliverpb.Chown, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Chown not implemented")
}
func (UnimplementedSliverRPCServer) Chtimes(context.Context, *sliverpb.ChtimesReq) (*sliverpb.Chtimes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Chtimes not implemented")
}
func (UnimplementedSliverRPCServer) MemfilesList(context.Context, *sliverpb.MemfilesListReq) (*sliverpb.Ls, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MemfilesList not implemented")
}
func (UnimplementedSliverRPCServer) MemfilesAdd(context.Context, *sliverpb.MemfilesAddReq) (*sliverpb.MemfilesAdd, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MemfilesAdd not implemented")
}
func (UnimplementedSliverRPCServer) MemfilesRm(context.Context, *sliverpb.MemfilesRmReq) (*sliverpb.MemfilesRm, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MemfilesRm not implemented")
}
func (UnimplementedSliverRPCServer) Mount(context.Context, *sliverpb.MountReq) (*sliverpb.Mount, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mount not implemented")
}
func (UnimplementedSliverRPCServer) ProcessDump(context.Context, *sliverpb.ProcessDumpReq) (*sliverpb.ProcessDump, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessDump not implemented")
}
func (UnimplementedSliverRPCServer) RunAs(context.Context, *sliverpb.RunAsReq) (*sliverpb.RunAs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunAs not implemented")
}
func (UnimplementedSliverRPCServer) Impersonate(context.Context, *sliverpb.ImpersonateReq) (*sliverpb.Impersonate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Impersonate not implemented")
}
func (UnimplementedSliverRPCServer) RevToSelf(context.Context, *sliverpb.RevToSelfReq) (*sliverpb.RevToSelf, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevToSelf not implemented")
}
func (UnimplementedSliverRPCServer) GetSystem(context.Context, *clientpb.GetSystemReq) (*sliverpb.GetSystem, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSystem not implemented")
}
func (UnimplementedSliverRPCServer) Task(context.Context, *sliverpb.TaskReq) (*sliverpb.Task, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Task not implemented")
}
func (UnimplementedSliverRPCServer) Msf(context.Context, *clientpb.MSFReq) (*sliverpb.Task, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Msf not implemented")
}
func (UnimplementedSliverRPCServer) MsfRemote(context.Context, *clientpb.MSFRemoteReq) (*sliverpb.Task, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsfRemote not implemented")
}
func (UnimplementedSliverRPCServer) ExecuteAssembly(context.Context, *sliverpb.ExecuteAssemblyReq) (*sliverpb.ExecuteAssembly, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteAssembly not implemented")
}
func (UnimplementedSliverRPCServer) Migrate(context.Context, *clientpb.MigrateReq) (*sliverpb.Migrate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Migrate not implemented")
}
func (UnimplementedSliverRPCServer) Execute(context.Context, *sliverpb.ExecuteReq) (*sliverpb.Execute, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Execute not implemented")
}
func (UnimplementedSliverRPCServer) ExecuteWindows(context.Context, *sliverpb.ExecuteWindowsReq) (*sliverpb.Execute, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteWindows not implemented")
}
func (UnimplementedSliverRPCServer) Sideload(context.Context, *sliverpb.SideloadReq) (*sliverpb.Sideload, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sideload not implemented")
}
func (UnimplementedSliverRPCServer) SpawnDll(context.Context, *sliverpb.InvokeSpawnDllReq) (*sliverpb.SpawnDll, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SpawnDll not implemented")
}
func (UnimplementedSliverRPCServer) Screenshot(context.Context, *sliverpb.ScreenshotReq) (*sliverpb.Screenshot, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Screenshot not implemented")
}
func (UnimplementedSliverRPCServer) CurrentTokenOwner(context.Context, *sliverpb.CurrentTokenOwnerReq) (*sliverpb.CurrentTokenOwner, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrentTokenOwner not implemented")
}
func (UnimplementedSliverRPCServer) Services(context.Context, *sliverpb.ServicesReq) (*sliverpb.Services, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Services not implemented")
}
func (UnimplementedSliverRPCServer) ServiceDetail(context.Context, *sliverpb.ServiceDetailReq) (*sliverpb.ServiceDetail, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ServiceDetail not implemented")
}
func (UnimplementedSliverRPCServer) StartServiceByName(context.Context, *sliverpb.StartServiceByNameReq) (*sliverpb.ServiceInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartServiceByName not implemented")
}
func (UnimplementedSliverRPCServer) PivotStartListener(context.Context, *sliverpb.PivotStartListenerReq) (*sliverpb.PivotListener, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PivotStartListener not implemented")
}
func (UnimplementedSliverRPCServer) PivotStopListener(context.Context, *sliverpb.PivotStopListenerReq) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PivotStopListener not implemented")
}
func (UnimplementedSliverRPCServer) PivotSessionListeners(context.Context, *sliverpb.PivotListenersReq) (*sliverpb.PivotListeners, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PivotSessionListeners not implemented")
}
func (UnimplementedSliverRPCServer) PivotGraph(context.Context, *commonpb.Empty) (*clientpb.PivotGraph, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PivotGraph not implemented")
}
func (UnimplementedSliverRPCServer) StartService(context.Context, *sliverpb.StartServiceReq) (*sliverpb.ServiceInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartService not implemented")
}
func (UnimplementedSliverRPCServer) StopService(context.Context, *sliverpb.StopServiceReq) (*sliverpb.ServiceInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopService not implemented")
}
func (UnimplementedSliverRPCServer) RemoveService(context.Context, *sliverpb.RemoveServiceReq) (*sliverpb.ServiceInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveService not implemented")
}
func (UnimplementedSliverRPCServer) MakeToken(context.Context, *sliverpb.MakeTokenReq) (*sliverpb.MakeToken, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MakeToken not implemented")
}
func (UnimplementedSliverRPCServer) GetEnv(context.Context, *sliverpb.EnvReq) (*sliverpb.EnvInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEnv not implemented")
}
func (UnimplementedSliverRPCServer) SetEnv(context.Context, *sliverpb.SetEnvReq) (*sliverpb.SetEnv, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetEnv not implemented")
}
func (UnimplementedSliverRPCServer) UnsetEnv(context.Context, *sliverpb.UnsetEnvReq) (*sliverpb.UnsetEnv, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsetEnv not implemented")
}
func (UnimplementedSliverRPCServer) Backdoor(context.Context, *clientpb.BackdoorReq) (*clientpb.Backdoor, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Backdoor not implemented")
}
func (UnimplementedSliverRPCServer) RegistryRead(context.Context, *sliverpb.RegistryReadReq) (*sliverpb.RegistryRead, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryRead not implemented")
}
func (UnimplementedSliverRPCServer) RegistryWrite(context.Context, *sliverpb.RegistryWriteReq) (*sliverpb.RegistryWrite, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryWrite not implemented")
}
func (UnimplementedSliverRPCServer) RegistryCreateKey(context.Context, *sliverpb.RegistryCreateKeyReq) (*sliverpb.RegistryCreateKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryCreateKey not implemented")
}
func (UnimplementedSliverRPCServer) RegistryDeleteKey(context.Context, *sliverpb.RegistryDeleteKeyReq) (*sliverpb.RegistryDeleteKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryDeleteKey not implemented")
}
func (UnimplementedSliverRPCServer) RegistryListSubKeys(context.Context, *sliverpb.RegistrySubKeyListReq) (*sliverpb.RegistrySubKeyList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryListSubKeys not implemented")
}
func (UnimplementedSliverRPCServer) RegistryListValues(context.Context, *sliverpb.RegistryListValuesReq) (*sliverpb.RegistryValuesList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryListValues not implemented")
}
func (UnimplementedSliverRPCServer) RegistryReadHive(context.Context, *sliverpb.RegistryReadHiveReq) (*sliverpb.RegistryReadHive, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegistryReadHive not implemented")
}
func (UnimplementedSliverRPCServer) RunSSHCommand(context.Context, *sliverpb.SSHCommandReq) (*sliverpb.SSHCommand, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunSSHCommand not implemented")
}
func (UnimplementedSliverRPCServer) HijackDLL(context.Context, *clientpb.DllHijackReq) (*clientpb.DllHijack, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HijackDLL not implemented")
}
func (UnimplementedSliverRPCServer) GetPrivs(context.Context, *sliverpb.GetPrivsReq) (*sliverpb.GetPrivs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivs not implemented")
}
func (UnimplementedSliverRPCServer) StartRportFwdListener(context.Context, *sliverpb.RportFwdStartListenerReq) (*sliverpb.RportFwdListener, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartRportFwdListener not implemented")
}
func (UnimplementedSliverRPCServer) GetRportFwdListeners(context.Context, *sliverpb.RportFwdListenersReq) (*sliverpb.RportFwdListeners, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRportFwdListeners not implemented")
}
func (UnimplementedSliverRPCServer) StopRportFwdListener(context.Context, *sliverpb.RportFwdStopListenerReq) (*sliverpb.RportFwdListener, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopRportFwdListener not implemented")
}
func (UnimplementedSliverRPCServer) OpenSession(context.Context, *sliverpb.OpenSession) (*sliverpb.OpenSession, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenSession not implemented")
}
func (UnimplementedSliverRPCServer) CloseSession(context.Context, *sliverpb.CloseSession) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseSession not implemented")
}
func (UnimplementedSliverRPCServer) RegisterExtension(context.Context, *sliverpb.RegisterExtensionReq) (*sliverpb.RegisterExtension, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterExtension not implemented")
}
func (UnimplementedSliverRPCServer) CallExtension(context.Context, *sliverpb.CallExtensionReq) (*sliverpb.CallExtension, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CallExtension not implemented")
}
func (UnimplementedSliverRPCServer) ListExtensions(context.Context, *sliverpb.ListExtensionsReq) (*sliverpb.ListExtensions, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListExtensions not implemented")
}
func (UnimplementedSliverRPCServer) RegisterWasmExtension(context.Context, *sliverpb.RegisterWasmExtensionReq) (*sliverpb.RegisterWasmExtension, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterWasmExtension not implemented")
}
func (UnimplementedSliverRPCServer) ListWasmExtensions(context.Context, *sliverpb.ListWasmExtensionsReq) (*sliverpb.ListWasmExtensions, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWasmExtensions not implemented")
}
func (UnimplementedSliverRPCServer) ExecWasmExtension(context.Context, *sliverpb.ExecWasmExtensionReq) (*sliverpb.ExecWasmExtension, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecWasmExtension not implemented")
}
func (UnimplementedSliverRPCServer) WGStartPortForward(context.Context, *sliverpb.WGPortForwardStartReq) (*sliverpb.WGPortForward, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGStartPortForward not implemented")
}
func (UnimplementedSliverRPCServer) WGStopPortForward(context.Context, *sliverpb.WGPortForwardStopReq) (*sliverpb.WGPortForward, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGStopPortForward not implemented")
}
func (UnimplementedSliverRPCServer) WGStartSocks(context.Context, *sliverpb.WGSocksStartReq) (*sliverpb.WGSocks, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGStartSocks not implemented")
}
func (UnimplementedSliverRPCServer) WGStopSocks(context.Context, *sliverpb.WGSocksStopReq) (*sliverpb.WGSocks, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGStopSocks not implemented")
}
func (UnimplementedSliverRPCServer) WGListForwarders(context.Context, *sliverpb.WGTCPForwardersReq) (*sliverpb.WGTCPForwarders, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGListForwarders not implemented")
}
func (UnimplementedSliverRPCServer) WGListSocksServers(context.Context, *sliverpb.WGSocksServersReq) (*sliverpb.WGSocksServers, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WGListSocksServers not implemented")
}
func (UnimplementedSliverRPCServer) Shell(context.Context, *sliverpb.ShellReq) (*sliverpb.Shell, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Shell not implemented")
}
func (UnimplementedSliverRPCServer) Portfwd(context.Context, *sliverpb.PortfwdReq) (*sliverpb.Portfwd, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Portfwd not implemented")
}
func (UnimplementedSliverRPCServer) CreateSocks(context.Context, *sliverpb.Socks) (*sliverpb.Socks, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSocks not implemented")
}
func (UnimplementedSliverRPCServer) CloseSocks(context.Context, *sliverpb.Socks) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseSocks not implemented")
}
func (UnimplementedSliverRPCServer) SocksProxy(grpc.BidiStreamingServer[sliverpb.SocksData, sliverpb.SocksData]) error {
	return status.Errorf(codes.Unimplemented, "method SocksProxy not implemented")
}
func (UnimplementedSliverRPCServer) CreateTunnel(context.Context, *sliverpb.Tunnel) (*sliverpb.Tunnel, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTunnel not implemented")
}
func (UnimplementedSliverRPCServer) CloseTunnel(context.Context, *sliverpb.Tunnel) (*commonpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseTunnel not implemented")
}
func (UnimplementedSliverRPCServer) TunnelData(grpc.BidiStreamingServer[sliverpb.TunnelData, sliverpb.TunnelData]) error {
	return status.Errorf(codes.Unimplemented, "method TunnelData not implemented")
}
func (UnimplementedSliverRPCServer) Events(*commonpb.Empty, grpc.ServerStreamingServer[clientpb.Event]) error {
	return status.Errorf(codes.Unimplemented, "method Events not implemented")
}
func (UnimplementedSliverRPCServer) mustEmbedUnimplementedSliverRPCServer() {}
func (UnimplementedSliverRPCServer) testEmbeddedByValue()                   {}

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

func RegisterSliverRPCServer(s grpc.ServiceRegistrar, srv SliverRPCServer) {
	// If the following call pancis, it indicates UnimplementedSliverRPCServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&SliverRPC_ServiceDesc, srv)
}

func _SliverRPC_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetVersion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetVersion(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ClientLog_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SliverRPCServer).ClientLog(&grpc.GenericServerStream[clientpb.ClientLogData, commonpb.Empty]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_ClientLogServer = grpc.ClientStreamingServer[clientpb.ClientLogData, commonpb.Empty]

func _SliverRPC_GetOperators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetOperators(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetOperators_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetOperators(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Kill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.KillReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Kill(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Kill_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Kill(ctx, req.(*sliverpb.KillReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Reconfigure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ReconfigureReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Reconfigure(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Reconfigure_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Reconfigure(ctx, req.(*sliverpb.ReconfigureReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Rename_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.RenameReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Rename(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Rename_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Rename(ctx, req.(*clientpb.RenameReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetSessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetSessions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetSessions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetSessions(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MonitorStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MonitorStart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MonitorStart_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MonitorStart(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MonitorStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MonitorStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MonitorStop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MonitorStop(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MonitorListConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MonitorListConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MonitorListConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MonitorListConfig(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MonitorAddConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MonitoringProvider)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MonitorAddConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MonitorAddConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MonitorAddConfig(ctx, req.(*clientpb.MonitoringProvider))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MonitorDelConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MonitoringProvider)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MonitorDelConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MonitorDelConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MonitorDelConfig(ctx, req.(*clientpb.MonitoringProvider))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartMTLSListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MTLSListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartMTLSListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartMTLSListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartMTLSListener(ctx, req.(*clientpb.MTLSListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartWGListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.WGListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartWGListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartWGListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartWGListener(ctx, req.(*clientpb.WGListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartDNSListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.DNSListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartDNSListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartDNSListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartDNSListener(ctx, req.(*clientpb.DNSListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartHTTPSListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.HTTPListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartHTTPSListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartHTTPSListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartHTTPSListener(ctx, req.(*clientpb.HTTPListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartHTTPListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.HTTPListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartHTTPListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartHTTPListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartHTTPListener(ctx, req.(*clientpb.HTTPListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetBeacons_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetBeacons(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetBeacons_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetBeacons(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetBeacon_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Beacon)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetBeacon(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetBeacon_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetBeacon(ctx, req.(*clientpb.Beacon))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RmBeacon_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Beacon)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RmBeacon(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RmBeacon_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RmBeacon(ctx, req.(*clientpb.Beacon))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetBeaconTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Beacon)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetBeaconTasks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetBeaconTasks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetBeaconTasks(ctx, req.(*clientpb.Beacon))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetBeaconTaskContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.BeaconTask)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetBeaconTaskContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetBeaconTaskContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetBeaconTaskContent(ctx, req.(*clientpb.BeaconTask))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CancelBeaconTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.BeaconTask)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CancelBeaconTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CancelBeaconTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CancelBeaconTask(ctx, req.(*clientpb.BeaconTask))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_UpdateBeaconIntegrityInformation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.BeaconIntegrity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).UpdateBeaconIntegrityInformation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_UpdateBeaconIntegrityInformation_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).UpdateBeaconIntegrityInformation(ctx, req.(*clientpb.BeaconIntegrity))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetJobs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetJobs(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_KillJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.KillJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).KillJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_KillJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).KillJob(ctx, req.(*clientpb.KillJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RestartJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.RestartJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RestartJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RestartJobs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RestartJobs(ctx, req.(*clientpb.RestartJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartTCPStagerListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.StagerListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartTCPStagerListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartTCPStagerListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartTCPStagerListener(ctx, req.(*clientpb.StagerListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_LootAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Loot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).LootAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_LootAdd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).LootAdd(ctx, req.(*clientpb.Loot))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_LootRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Loot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).LootRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_LootRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).LootRm(ctx, req.(*clientpb.Loot))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_LootUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Loot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).LootUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_LootUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).LootUpdate(ctx, req.(*clientpb.Loot))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_LootContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Loot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).LootContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_LootContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).LootContent(ctx, req.(*clientpb.Loot))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_LootAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).LootAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_LootAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).LootAll(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Creds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Creds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Creds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Creds(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CredsAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credentials)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CredsAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CredsAdd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CredsAdd(ctx, req.(*clientpb.Credentials))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CredsRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credentials)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CredsRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CredsRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CredsRm(ctx, req.(*clientpb.Credentials))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CredsUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credentials)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CredsUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CredsUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CredsUpdate(ctx, req.(*clientpb.Credentials))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetCredByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credential)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetCredByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetCredByID_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetCredByID(ctx, req.(*clientpb.Credential))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetCredsByHashType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credential)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetCredsByHashType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetCredsByHashType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetCredsByHashType(ctx, req.(*clientpb.Credential))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetPlaintextCredsByHashType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credential)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetPlaintextCredsByHashType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetPlaintextCredsByHashType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetPlaintextCredsByHashType(ctx, req.(*clientpb.Credential))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CredsSniffHashType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Credential)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CredsSniffHashType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CredsSniffHashType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CredsSniffHashType(ctx, req.(*clientpb.Credential))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Hosts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Hosts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Hosts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Hosts(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Host_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Host)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Host(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Host_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Host(ctx, req.(*clientpb.Host))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_HostRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Host)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).HostRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_HostRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).HostRm(ctx, req.(*clientpb.Host))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_HostIOCRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.IOC)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).HostIOCRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_HostIOCRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).HostIOCRm(ctx, req.(*clientpb.IOC))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Generate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.GenerateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Generate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Generate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Generate(ctx, req.(*clientpb.GenerateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateExternal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ExternalGenerateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateExternal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateExternal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateExternal(ctx, req.(*clientpb.ExternalGenerateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateExternalSaveBuild_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ExternalImplantBinary)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateExternalSaveBuild(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateExternalSaveBuild_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateExternalSaveBuild(ctx, req.(*clientpb.ExternalImplantBinary))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateExternalGetBuildConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ImplantBuild)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateExternalGetBuildConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateExternalGetBuildConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateExternalGetBuildConfig(ctx, req.(*clientpb.ImplantBuild))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateStage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.GenerateStageReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateStage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateStage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateStage(ctx, req.(*clientpb.GenerateStageReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StageImplantBuild_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ImplantStageReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StageImplantBuild(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StageImplantBuild_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StageImplantBuild(ctx, req.(*clientpb.ImplantStageReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetHTTPC2Profiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetHTTPC2Profiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetHTTPC2Profiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetHTTPC2Profiles(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetHTTPC2ProfileByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.C2ProfileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetHTTPC2ProfileByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetHTTPC2ProfileByName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetHTTPC2ProfileByName(ctx, req.(*clientpb.C2ProfileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_SaveHTTPC2Profile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.HTTPC2ConfigReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).SaveHTTPC2Profile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_SaveHTTPC2Profile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).SaveHTTPC2Profile(ctx, req.(*clientpb.HTTPC2ConfigReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_BuilderRegister_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(clientpb.Builder)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SliverRPCServer).BuilderRegister(m, &grpc.GenericServerStream[clientpb.Builder, clientpb.Event]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_BuilderRegisterServer = grpc.ServerStreamingServer[clientpb.Event]

func _SliverRPC_BuilderTrigger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Event)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).BuilderTrigger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_BuilderTrigger_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).BuilderTrigger(ctx, req.(*clientpb.Event))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Builders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Builders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Builders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Builders(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetCertificateInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CertificatesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetCertificateInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetCertificateInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetCertificateInfo(ctx, req.(*clientpb.CertificatesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackstationRegister_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(clientpb.Crackstation)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SliverRPCServer).CrackstationRegister(m, &grpc.GenericServerStream[clientpb.Crackstation, clientpb.Event]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_CrackstationRegisterServer = grpc.ServerStreamingServer[clientpb.Event]

func _SliverRPC_CrackstationTrigger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Event)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackstationTrigger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackstationTrigger_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackstationTrigger(ctx, req.(*clientpb.Event))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackstationBenchmark_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackBenchmark)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackstationBenchmark(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackstationBenchmark_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackstationBenchmark(ctx, req.(*clientpb.CrackBenchmark))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Crackstations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Crackstations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Crackstations_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Crackstations(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackTaskByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackTask)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackTaskByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackTaskByID_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackTaskByID(ctx, req.(*clientpb.CrackTask))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackTaskUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackTask)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackTaskUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackTaskUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackTaskUpdate(ctx, req.(*clientpb.CrackTask))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFilesList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFilesList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFilesList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFilesList(ctx, req.(*clientpb.CrackFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFileCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFileCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFileCreate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFileCreate(ctx, req.(*clientpb.CrackFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFileChunkUpload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFileChunk)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFileChunkUpload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFileChunkUpload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFileChunkUpload(ctx, req.(*clientpb.CrackFileChunk))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFileChunkDownload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFileChunk)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFileChunkDownload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFileChunkDownload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFileChunkDownload(ctx, req.(*clientpb.CrackFileChunk))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFileComplete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFileComplete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFileComplete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFileComplete(ctx, req.(*clientpb.CrackFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CrackFileDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.CrackFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CrackFileDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CrackFileDelete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CrackFileDelete(ctx, req.(*clientpb.CrackFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Regenerate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.RegenerateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Regenerate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Regenerate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Regenerate(ctx, req.(*clientpb.RegenerateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ImplantBuilds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ImplantBuilds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ImplantBuilds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ImplantBuilds(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_DeleteImplantBuild_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.DeleteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).DeleteImplantBuild(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_DeleteImplantBuild_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).DeleteImplantBuild(ctx, req.(*clientpb.DeleteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Canaries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Canaries(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Canaries_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Canaries(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateWGClientConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateWGClientConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateWGClientConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateWGClientConfig(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GenerateUniqueIP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GenerateUniqueIP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GenerateUniqueIP_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GenerateUniqueIP(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ImplantProfiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ImplantProfiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ImplantProfiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ImplantProfiles(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_DeleteImplantProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.DeleteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).DeleteImplantProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_DeleteImplantProfile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).DeleteImplantProfile(ctx, req.(*clientpb.DeleteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_SaveImplantProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ImplantProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).SaveImplantProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_SaveImplantProfile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).SaveImplantProfile(ctx, req.(*clientpb.ImplantProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ShellcodeRDI_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ShellcodeRDIReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ShellcodeRDI(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ShellcodeRDI_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ShellcodeRDI(ctx, req.(*clientpb.ShellcodeRDIReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetCompiler_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetCompiler(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetCompiler_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetCompiler(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ShellcodeEncoder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.ShellcodeEncodeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ShellcodeEncoder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ShellcodeEncoder_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ShellcodeEncoder(ctx, req.(*clientpb.ShellcodeEncodeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ShellcodeEncoderMap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ShellcodeEncoderMap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ShellcodeEncoderMap_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ShellcodeEncoderMap(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_TrafficEncoderMap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).TrafficEncoderMap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_TrafficEncoderMap_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).TrafficEncoderMap(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_TrafficEncoderAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.TrafficEncoder)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).TrafficEncoderAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_TrafficEncoderAdd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).TrafficEncoderAdd(ctx, req.(*clientpb.TrafficEncoder))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_TrafficEncoderRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.TrafficEncoder)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).TrafficEncoderRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_TrafficEncoderRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).TrafficEncoderRm(ctx, req.(*clientpb.TrafficEncoder))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Websites_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Websites(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Websites_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Websites(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Website_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Website)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Website(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Website_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Website(ctx, req.(*clientpb.Website))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WebsiteRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.Website)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WebsiteRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WebsiteRemove_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WebsiteRemove(ctx, req.(*clientpb.Website))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WebsiteAddContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.WebsiteAddContent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WebsiteAddContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WebsiteAddContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WebsiteAddContent(ctx, req.(*clientpb.WebsiteAddContent))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WebsiteUpdateContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.WebsiteAddContent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WebsiteUpdateContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WebsiteUpdateContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WebsiteUpdateContent(ctx, req.(*clientpb.WebsiteAddContent))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WebsiteRemoveContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.WebsiteRemoveContent)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WebsiteRemoveContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WebsiteRemoveContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WebsiteRemoveContent(ctx, req.(*clientpb.WebsiteRemoveContent))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.Ping)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Ping_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Ping(ctx, req.(*sliverpb.Ping))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Ps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Ps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Ps_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Ps(ctx, req.(*sliverpb.PsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Terminate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.TerminateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Terminate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Terminate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Terminate(ctx, req.(*sliverpb.TerminateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Ifconfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.IfconfigReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Ifconfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Ifconfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Ifconfig(ctx, req.(*sliverpb.IfconfigReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Netstat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.NetstatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Netstat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Netstat_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Netstat(ctx, req.(*sliverpb.NetstatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Ls_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.LsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Ls(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Ls_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Ls(ctx, req.(*sliverpb.LsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Cd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.CdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Cd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Cd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Cd(ctx, req.(*sliverpb.CdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Pwd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PwdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Pwd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Pwd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Pwd(ctx, req.(*sliverpb.PwdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Mv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MvReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Mv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Mv_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Mv(ctx, req.(*sliverpb.MvReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Cp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.CpReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Cp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Cp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Cp(ctx, req.(*sliverpb.CpReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Rm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RmReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Rm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Rm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Rm(ctx, req.(*sliverpb.RmReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Mkdir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MkdirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Mkdir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Mkdir_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Mkdir(ctx, req.(*sliverpb.MkdirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Download_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.DownloadReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Download(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Download_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Download(ctx, req.(*sliverpb.DownloadReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Upload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.UploadReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Upload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Upload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Upload(ctx, req.(*sliverpb.UploadReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Grep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.GrepReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Grep(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Grep_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Grep(ctx, req.(*sliverpb.GrepReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Chmod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ChmodReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Chmod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Chmod_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Chmod(ctx, req.(*sliverpb.ChmodReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Chown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ChownReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Chown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Chown_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Chown(ctx, req.(*sliverpb.ChownReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Chtimes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ChtimesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Chtimes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Chtimes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Chtimes(ctx, req.(*sliverpb.ChtimesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MemfilesList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MemfilesListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MemfilesList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MemfilesList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MemfilesList(ctx, req.(*sliverpb.MemfilesListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MemfilesAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MemfilesAddReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MemfilesAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MemfilesAdd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MemfilesAdd(ctx, req.(*sliverpb.MemfilesAddReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MemfilesRm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MemfilesRmReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MemfilesRm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MemfilesRm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MemfilesRm(ctx, req.(*sliverpb.MemfilesRmReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Mount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Mount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Mount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Mount(ctx, req.(*sliverpb.MountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ProcessDump_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ProcessDumpReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ProcessDump(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ProcessDump_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ProcessDump(ctx, req.(*sliverpb.ProcessDumpReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RunAs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RunAsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RunAs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RunAs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RunAs(ctx, req.(*sliverpb.RunAsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Impersonate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ImpersonateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Impersonate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Impersonate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Impersonate(ctx, req.(*sliverpb.ImpersonateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RevToSelf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RevToSelfReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RevToSelf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RevToSelf_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RevToSelf(ctx, req.(*sliverpb.RevToSelfReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetSystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.GetSystemReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetSystem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetSystem_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetSystem(ctx, req.(*clientpb.GetSystemReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Task_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.TaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Task(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Task_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Task(ctx, req.(*sliverpb.TaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Msf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MSFReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Msf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Msf_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Msf(ctx, req.(*clientpb.MSFReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MsfRemote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MSFRemoteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MsfRemote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MsfRemote_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MsfRemote(ctx, req.(*clientpb.MSFRemoteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ExecuteAssembly_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ExecuteAssemblyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ExecuteAssembly(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ExecuteAssembly_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ExecuteAssembly(ctx, req.(*sliverpb.ExecuteAssemblyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Migrate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.MigrateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Migrate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Migrate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Migrate(ctx, req.(*clientpb.MigrateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Execute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ExecuteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Execute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Execute_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Execute(ctx, req.(*sliverpb.ExecuteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ExecuteWindows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ExecuteWindowsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ExecuteWindows(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ExecuteWindows_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ExecuteWindows(ctx, req.(*sliverpb.ExecuteWindowsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Sideload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.SideloadReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Sideload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Sideload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Sideload(ctx, req.(*sliverpb.SideloadReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_SpawnDll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.InvokeSpawnDllReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).SpawnDll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_SpawnDll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).SpawnDll(ctx, req.(*sliverpb.InvokeSpawnDllReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Screenshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ScreenshotReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Screenshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Screenshot_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Screenshot(ctx, req.(*sliverpb.ScreenshotReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CurrentTokenOwner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.CurrentTokenOwnerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CurrentTokenOwner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CurrentTokenOwner_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CurrentTokenOwner(ctx, req.(*sliverpb.CurrentTokenOwnerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Services_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ServicesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Services(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Services_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Services(ctx, req.(*sliverpb.ServicesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ServiceDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ServiceDetailReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ServiceDetail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ServiceDetail_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ServiceDetail(ctx, req.(*sliverpb.ServiceDetailReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartServiceByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.StartServiceByNameReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartServiceByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartServiceByName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartServiceByName(ctx, req.(*sliverpb.StartServiceByNameReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_PivotStartListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PivotStartListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).PivotStartListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_PivotStartListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).PivotStartListener(ctx, req.(*sliverpb.PivotStartListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_PivotStopListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PivotStopListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).PivotStopListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_PivotStopListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).PivotStopListener(ctx, req.(*sliverpb.PivotStopListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_PivotSessionListeners_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PivotListenersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).PivotSessionListeners(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_PivotSessionListeners_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).PivotSessionListeners(ctx, req.(*sliverpb.PivotListenersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_PivotGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(commonpb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).PivotGraph(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_PivotGraph_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).PivotGraph(ctx, req.(*commonpb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.StartServiceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartService(ctx, req.(*sliverpb.StartServiceReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StopService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.StopServiceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StopService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StopService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StopService(ctx, req.(*sliverpb.StopServiceReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RemoveService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RemoveServiceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RemoveService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RemoveService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RemoveService(ctx, req.(*sliverpb.RemoveServiceReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_MakeToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.MakeTokenReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).MakeToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_MakeToken_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).MakeToken(ctx, req.(*sliverpb.MakeTokenReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetEnv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.EnvReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetEnv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetEnv_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetEnv(ctx, req.(*sliverpb.EnvReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_SetEnv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.SetEnvReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).SetEnv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_SetEnv_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).SetEnv(ctx, req.(*sliverpb.SetEnvReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_UnsetEnv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.UnsetEnvReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).UnsetEnv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_UnsetEnv_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).UnsetEnv(ctx, req.(*sliverpb.UnsetEnvReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Backdoor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.BackdoorReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Backdoor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Backdoor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Backdoor(ctx, req.(*clientpb.BackdoorReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryReadReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryRead_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryRead(ctx, req.(*sliverpb.RegistryReadReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryWrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryWriteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryWrite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryWrite_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryWrite(ctx, req.(*sliverpb.RegistryWriteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryCreateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryCreateKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryCreateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryCreateKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryCreateKey(ctx, req.(*sliverpb.RegistryCreateKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryDeleteKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryDeleteKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryDeleteKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryDeleteKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryDeleteKey(ctx, req.(*sliverpb.RegistryDeleteKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryListSubKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistrySubKeyListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryListSubKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryListSubKeys_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryListSubKeys(ctx, req.(*sliverpb.RegistrySubKeyListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryListValues_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryListValuesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryListValues(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryListValues_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryListValues(ctx, req.(*sliverpb.RegistryListValuesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegistryReadHive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegistryReadHiveReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegistryReadHive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegistryReadHive_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegistryReadHive(ctx, req.(*sliverpb.RegistryReadHiveReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RunSSHCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.SSHCommandReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RunSSHCommand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RunSSHCommand_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RunSSHCommand(ctx, req.(*sliverpb.SSHCommandReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_HijackDLL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(clientpb.DllHijackReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).HijackDLL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_HijackDLL_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).HijackDLL(ctx, req.(*clientpb.DllHijackReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetPrivs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.GetPrivsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetPrivs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetPrivs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetPrivs(ctx, req.(*sliverpb.GetPrivsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StartRportFwdListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RportFwdStartListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StartRportFwdListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StartRportFwdListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StartRportFwdListener(ctx, req.(*sliverpb.RportFwdStartListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_GetRportFwdListeners_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RportFwdListenersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).GetRportFwdListeners(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_GetRportFwdListeners_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).GetRportFwdListeners(ctx, req.(*sliverpb.RportFwdListenersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_StopRportFwdListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RportFwdStopListenerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).StopRportFwdListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_StopRportFwdListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).StopRportFwdListener(ctx, req.(*sliverpb.RportFwdStopListenerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_OpenSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.OpenSession)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).OpenSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_OpenSession_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).OpenSession(ctx, req.(*sliverpb.OpenSession))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CloseSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.CloseSession)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CloseSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CloseSession_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CloseSession(ctx, req.(*sliverpb.CloseSession))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegisterExtension_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegisterExtensionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegisterExtension(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegisterExtension_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegisterExtension(ctx, req.(*sliverpb.RegisterExtensionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CallExtension_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.CallExtensionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CallExtension(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CallExtension_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CallExtension(ctx, req.(*sliverpb.CallExtensionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ListExtensions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ListExtensionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ListExtensions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ListExtensions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ListExtensions(ctx, req.(*sliverpb.ListExtensionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_RegisterWasmExtension_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.RegisterWasmExtensionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).RegisterWasmExtension(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_RegisterWasmExtension_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).RegisterWasmExtension(ctx, req.(*sliverpb.RegisterWasmExtensionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ListWasmExtensions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ListWasmExtensionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ListWasmExtensions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ListWasmExtensions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ListWasmExtensions(ctx, req.(*sliverpb.ListWasmExtensionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_ExecWasmExtension_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ExecWasmExtensionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).ExecWasmExtension(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_ExecWasmExtension_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).ExecWasmExtension(ctx, req.(*sliverpb.ExecWasmExtensionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGStartPortForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGPortForwardStartReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGStartPortForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGStartPortForward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGStartPortForward(ctx, req.(*sliverpb.WGPortForwardStartReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGStopPortForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGPortForwardStopReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGStopPortForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGStopPortForward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGStopPortForward(ctx, req.(*sliverpb.WGPortForwardStopReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGStartSocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGSocksStartReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGStartSocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGStartSocks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGStartSocks(ctx, req.(*sliverpb.WGSocksStartReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGStopSocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGSocksStopReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGStopSocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGStopSocks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGStopSocks(ctx, req.(*sliverpb.WGSocksStopReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGListForwarders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGTCPForwardersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGListForwarders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGListForwarders_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGListForwarders(ctx, req.(*sliverpb.WGTCPForwardersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_WGListSocksServers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.WGSocksServersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).WGListSocksServers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_WGListSocksServers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).WGListSocksServers(ctx, req.(*sliverpb.WGSocksServersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Shell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.ShellReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Shell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Shell_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Shell(ctx, req.(*sliverpb.ShellReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_Portfwd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.PortfwdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).Portfwd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_Portfwd_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).Portfwd(ctx, req.(*sliverpb.PortfwdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CreateSocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.Socks)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CreateSocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CreateSocks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CreateSocks(ctx, req.(*sliverpb.Socks))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CloseSocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.Socks)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CloseSocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CloseSocks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CloseSocks(ctx, req.(*sliverpb.Socks))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_SocksProxy_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SliverRPCServer).SocksProxy(&grpc.GenericServerStream[sliverpb.SocksData, sliverpb.SocksData]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_SocksProxyServer = grpc.BidiStreamingServer[sliverpb.SocksData, sliverpb.SocksData]

func _SliverRPC_CreateTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.Tunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CreateTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CreateTunnel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CreateTunnel(ctx, req.(*sliverpb.Tunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_CloseTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sliverpb.Tunnel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SliverRPCServer).CloseTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SliverRPC_CloseTunnel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SliverRPCServer).CloseTunnel(ctx, req.(*sliverpb.Tunnel))
	}
	return interceptor(ctx, in, info, handler)
}

func _SliverRPC_TunnelData_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SliverRPCServer).TunnelData(&grpc.GenericServerStream[sliverpb.TunnelData, sliverpb.TunnelData]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_TunnelDataServer = grpc.BidiStreamingServer[sliverpb.TunnelData, sliverpb.TunnelData]

func _SliverRPC_Events_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(commonpb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SliverRPCServer).Events(m, &grpc.GenericServerStream[commonpb.Empty, clientpb.Event]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type SliverRPC_EventsServer = grpc.ServerStreamingServer[clientpb.Event]

// SliverRPC_ServiceDesc is the grpc.ServiceDesc for SliverRPC service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SliverRPC_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.SliverRPC",
	HandlerType: (*SliverRPCServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetVersion",
			Handler:    _SliverRPC_GetVersion_Handler,
		},
		{
			MethodName: "GetOperators",
			Handler:    _SliverRPC_GetOperators_Handler,
		},
		{
			MethodName: "Kill",
			Handler:    _SliverRPC_Kill_Handler,
		},
		{
			MethodName: "Reconfigure",
			Handler:    _SliverRPC_Reconfigure_Handler,
		},
		{
			MethodName: "Rename",
			Handler:    _SliverRPC_Rename_Handler,
		},
		{
			MethodName: "GetSessions",
			Handler:    _SliverRPC_GetSessions_Handler,
		},
		{
			MethodName: "MonitorStart",
			Handler:    _SliverRPC_MonitorStart_Handler,
		},
		{
			MethodName: "MonitorStop",
			Handler:    _SliverRPC_MonitorStop_Handler,
		},
		{
			MethodName: "MonitorListConfig",
			Handler:    _SliverRPC_MonitorListConfig_Handler,
		},
		{
			MethodName: "MonitorAddConfig",
			Handler:    _SliverRPC_MonitorAddConfig_Handler,
		},
		{
			MethodName: "MonitorDelConfig",
			Handler:    _SliverRPC_MonitorDelConfig_Handler,
		},
		{
			MethodName: "StartMTLSListener",
			Handler:    _SliverRPC_StartMTLSListener_Handler,
		},
		{
			MethodName: "StartWGListener",
			Handler:    _SliverRPC_StartWGListener_Handler,
		},
		{
			MethodName: "StartDNSListener",
			Handler:    _SliverRPC_StartDNSListener_Handler,
		},
		{
			MethodName: "StartHTTPSListener",
			Handler:    _SliverRPC_StartHTTPSListener_Handler,
		},
		{
			MethodName: "StartHTTPListener",
			Handler:    _SliverRPC_StartHTTPListener_Handler,
		},
		{
			MethodName: "GetBeacons",
			Handler:    _SliverRPC_GetBeacons_Handler,
		},
		{
			MethodName: "GetBeacon",
			Handler:    _SliverRPC_GetBeacon_Handler,
		},
		{
			MethodName: "RmBeacon",
			Handler:    _SliverRPC_RmBeacon_Handler,
		},
		{
			MethodName: "GetBeaconTasks",
			Handler:    _SliverRPC_GetBeaconTasks_Handler,
		},
		{
			MethodName: "GetBeaconTaskContent",
			Handler:    _SliverRPC_GetBeaconTaskContent_Handler,
		},
		{
			MethodName: "CancelBeaconTask",
			Handler:    _SliverRPC_CancelBeaconTask_Handler,
		},
		{
			MethodName: "UpdateBeaconIntegrityInformation",
			Handler:    _SliverRPC_UpdateBeaconIntegrityInformation_Handler,
		},
		{
			MethodName: "GetJobs",
			Handler:    _SliverRPC_GetJobs_Handler,
		},
		{
			MethodName: "KillJob",
			Handler:    _SliverRPC_KillJob_Handler,
		},
		{
			MethodName: "RestartJobs",
			Handler:    _SliverRPC_RestartJobs_Handler,
		},
		{
			MethodName: "StartTCPStagerListener",
			Handler:    _SliverRPC_StartTCPStagerListener_Handler,
		},
		{
			MethodName: "LootAdd",
			Handler:    _SliverRPC_LootAdd_Handler,
		},
		{
			MethodName: "LootRm",
			Handler:    _SliverRPC_LootRm_Handler,
		},
		{
			MethodName: "LootUpdate",
			Handler:    _SliverRPC_LootUpdate_Handler,
		},
		{
			MethodName: "LootContent",
			Handler:    _SliverRPC_LootContent_Handler,
		},
		{
			MethodName: "LootAll",
			Handler:    _SliverRPC_LootAll_Handler,
		},
		{
			MethodName: "Creds",
			Handler:    _SliverRPC_Creds_Handler,
		},
		{
			MethodName: "CredsAdd",
			Handler:    _SliverRPC_CredsAdd_Handler,
		},
		{
			MethodName: "CredsRm",
			Handler:    _SliverRPC_CredsRm_Handler,
		},
		{
			MethodName: "CredsUpdate",
			Handler:    _SliverRPC_CredsUpdate_Handler,
		},
		{
			MethodName: "GetCredByID",
			Handler:    _SliverRPC_GetCredByID_Handler,
		},
		{
			MethodName: "GetCredsByHashType",
			Handler:    _SliverRPC_GetCredsByHashType_Handler,
		},
		{
			MethodName: "GetPlaintextCredsByHashType",
			Handler:    _SliverRPC_GetPlaintextCredsByHashType_Handler,
		},
		{
			MethodName: "CredsSniffHashType",
			Handler:    _SliverRPC_CredsSniffHashType_Handler,
		},
		{
			MethodName: "Hosts",
			Handler:    _SliverRPC_Hosts_Handler,
		},
		{
			MethodName: "Host",
			Handler:    _SliverRPC_Host_Handler,
		},
		{
			MethodName: "HostRm",
			Handler:    _SliverRPC_HostRm_Handler,
		},
		{
			MethodName: "HostIOCRm",
			Handler:    _SliverRPC_HostIOCRm_Handler,
		},
		{
			MethodName: "Generate",
			Handler:    _SliverRPC_Generate_Handler,
		},
		{
			MethodName: "GenerateExternal",
			Handler:    _SliverRPC_GenerateExternal_Handler,
		},
		{
			MethodName: "GenerateExternalSaveBuild",
			Handler:    _SliverRPC_GenerateExternalSaveBuild_Handler,
		},
		{
			MethodName: "GenerateExternalGetBuildConfig",
			Handler:    _SliverRPC_GenerateExternalGetBuildConfig_Handler,
		},
		{
			MethodName: "GenerateStage",
			Handler:    _SliverRPC_GenerateStage_Handler,
		},
		{
			MethodName: "StageImplantBuild",
			Handler:    _SliverRPC_StageImplantBuild_Handler,
		},
		{
			MethodName: "GetHTTPC2Profiles",
			Handler:    _SliverRPC_GetHTTPC2Profiles_Handler,
		},
		{
			MethodName: "GetHTTPC2ProfileByName",
			Handler:    _SliverRPC_GetHTTPC2ProfileByName_Handler,
		},
		{
			MethodName: "SaveHTTPC2Profile",
			Handler:    _SliverRPC_SaveHTTPC2Profile_Handler,
		},
		{
			MethodName: "BuilderTrigger",
			Handler:    _SliverRPC_BuilderTrigger_Handler,
		},
		{
			MethodName: "Builders",
			Handler:    _SliverRPC_Builders_Handler,
		},
		{
			MethodName: "GetCertificateInfo",
			Handler:    _SliverRPC_GetCertificateInfo_Handler,
		},
		{
			MethodName: "CrackstationTrigger",
			Handler:    _SliverRPC_CrackstationTrigger_Handler,
		},
		{
			MethodName: "CrackstationBenchmark",
			Handler:    _SliverRPC_CrackstationBenchmark_Handler,
		},
		{
			MethodName: "Crackstations",
			Handler:    _SliverRPC_Crackstations_Handler,
		},
		{
			MethodName: "CrackTaskByID",
			Handler:    _SliverRPC_CrackTaskByID_Handler,
		},
		{
			MethodName: "CrackTaskUpdate",
			Handler:    _SliverRPC_CrackTaskUpdate_Handler,
		},
		{
			MethodName: "CrackFilesList",
			Handler:    _SliverRPC_CrackFilesList_Handler,
		},
		{
			MethodName: "CrackFileCreate",
			Handler:    _SliverRPC_CrackFileCreate_Handler,
		},
		{
			MethodName: "CrackFileChunkUpload",
			Handler:    _SliverRPC_CrackFileChunkUpload_Handler,
		},
		{
			MethodName: "CrackFileChunkDownload",
			Handler:    _SliverRPC_CrackFileChunkDownload_Handler,
		},
		{
			MethodName: "CrackFileComplete",
			Handler:    _SliverRPC_CrackFileComplete_Handler,
		},
		{
			MethodName: "CrackFileDelete",
			Handler:    _SliverRPC_CrackFileDelete_Handler,
		},
		{
			MethodName: "Regenerate",
			Handler:    _SliverRPC_Regenerate_Handler,
		},
		{
			MethodName: "ImplantBuilds",
			Handler:    _SliverRPC_ImplantBuilds_Handler,
		},
		{
			MethodName: "DeleteImplantBuild",
			Handler:    _SliverRPC_DeleteImplantBuild_Handler,
		},
		{
			MethodName: "Canaries",
			Handler:    _SliverRPC_Canaries_Handler,
		},
		{
			MethodName: "GenerateWGClientConfig",
			Handler:    _SliverRPC_GenerateWGClientConfig_Handler,
		},
		{
			MethodName: "GenerateUniqueIP",
			Handler:    _SliverRPC_GenerateUniqueIP_Handler,
		},
		{
			MethodName: "ImplantProfiles",
			Handler:    _SliverRPC_ImplantProfiles_Handler,
		},
		{
			MethodName: "DeleteImplantProfile",
			Handler:    _SliverRPC_DeleteImplantProfile_Handler,
		},
		{
			MethodName: "SaveImplantProfile",
			Handler:    _SliverRPC_SaveImplantProfile_Handler,
		},
		{
			MethodName: "ShellcodeRDI",
			Handler:    _SliverRPC_ShellcodeRDI_Handler,
		},
		{
			MethodName: "GetCompiler",
			Handler:    _SliverRPC_GetCompiler_Handler,
		},
		{
			MethodName: "ShellcodeEncoder",
			Handler:    _SliverRPC_ShellcodeEncoder_Handler,
		},
		{
			MethodName: "ShellcodeEncoderMap",
			Handler:    _SliverRPC_ShellcodeEncoderMap_Handler,
		},
		{
			MethodName: "TrafficEncoderMap",
			Handler:    _SliverRPC_TrafficEncoderMap_Handler,
		},
		{
			MethodName: "TrafficEncoderAdd",
			Handler:    _SliverRPC_TrafficEncoderAdd_Handler,
		},
		{
			MethodName: "TrafficEncoderRm",
			Handler:    _SliverRPC_TrafficEncoderRm_Handler,
		},
		{
			MethodName: "Websites",
			Handler:    _SliverRPC_Websites_Handler,
		},
		{
			MethodName: "Website",
			Handler:    _SliverRPC_Website_Handler,
		},
		{
			MethodName: "WebsiteRemove",
			Handler:    _SliverRPC_WebsiteRemove_Handler,
		},
		{
			MethodName: "WebsiteAddContent",
			Handler:    _SliverRPC_WebsiteAddContent_Handler,
		},
		{
			MethodName: "WebsiteUpdateContent",
			Handler:    _SliverRPC_WebsiteUpdateContent_Handler,
		},
		{
			MethodName: "WebsiteRemoveContent",
			Handler:    _SliverRPC_WebsiteRemoveContent_Handler,
		},
		{
			MethodName: "Ping",
			Handler:    _SliverRPC_Ping_Handler,
		},
		{
			MethodName: "Ps",
			Handler:    _SliverRPC_Ps_Handler,
		},
		{
			MethodName: "Terminate",
			Handler:    _SliverRPC_Terminate_Handler,
		},
		{
			MethodName: "Ifconfig",
			Handler:    _SliverRPC_Ifconfig_Handler,
		},
		{
			MethodName: "Netstat",
			Handler:    _SliverRPC_Netstat_Handler,
		},
		{
			MethodName: "Ls",
			Handler:    _SliverRPC_Ls_Handler,
		},
		{
			MethodName: "Cd",
			Handler:    _SliverRPC_Cd_Handler,
		},
		{
			MethodName: "Pwd",
			Handler:    _SliverRPC_Pwd_Handler,
		},
		{
			MethodName: "Mv",
			Handler:    _SliverRPC_Mv_Handler,
		},
		{
			MethodName: "Cp",
			Handler:    _SliverRPC_Cp_Handler,
		},
		{
			MethodName: "Rm",
			Handler:    _SliverRPC_Rm_Handler,
		},
		{
			MethodName: "Mkdir",
			Handler:    _SliverRPC_Mkdir_Handler,
		},
		{
			MethodName: "Download",
			Handler:    _SliverRPC_Download_Handler,
		},
		{
			MethodName: "Upload",
			Handler:    _SliverRPC_Upload_Handler,
		},
		{
			MethodName: "Grep",
			Handler:    _SliverRPC_Grep_Handler,
		},
		{
			MethodName: "Chmod",
			Handler:    _SliverRPC_Chmod_Handler,
		},
		{
			MethodName: "Chown",
			Handler:    _SliverRPC_Chown_Handler,
		},
		{
			MethodName: "Chtimes",
			Handler:    _SliverRPC_Chtimes_Handler,
		},
		{
			MethodName: "MemfilesList",
			Handler:    _SliverRPC_MemfilesList_Handler,
		},
		{
			MethodName: "MemfilesAdd",
			Handler:    _SliverRPC_MemfilesAdd_Handler,
		},
		{
			MethodName: "MemfilesRm",
			Handler:    _SliverRPC_MemfilesRm_Handler,
		},
		{
			MethodName: "Mount",
			Handler:    _SliverRPC_Mount_Handler,
		},
		{
			MethodName: "ProcessDump",
			Handler:    _SliverRPC_ProcessDump_Handler,
		},
		{
			MethodName: "RunAs",
			Handler:    _SliverRPC_RunAs_Handler,
		},
		{
			MethodName: "Impersonate",
			Handler:    _SliverRPC_Impersonate_Handler,
		},
		{
			MethodName: "RevToSelf",
			Handler:    _SliverRPC_RevToSelf_Handler,
		},
		{
			MethodName: "GetSystem",
			Handler:    _SliverRPC_GetSystem_Handler,
		},
		{
			MethodName: "Task",
			Handler:    _SliverRPC_Task_Handler,
		},
		{
			MethodName: "Msf",
			Handler:    _SliverRPC_Msf_Handler,
		},
		{
			MethodName: "MsfRemote",
			Handler:    _SliverRPC_MsfRemote_Handler,
		},
		{
			MethodName: "ExecuteAssembly",
			Handler:    _SliverRPC_ExecuteAssembly_Handler,
		},
		{
			MethodName: "Migrate",
			Handler:    _SliverRPC_Migrate_Handler,
		},
		{
			MethodName: "Execute",
			Handler:    _SliverRPC_Execute_Handler,
		},
		{
			MethodName: "ExecuteWindows",
			Handler:    _SliverRPC_ExecuteWindows_Handler,
		},
		{
			MethodName: "Sideload",
			Handler:    _SliverRPC_Sideload_Handler,
		},
		{
			MethodName: "SpawnDll",
			Handler:    _SliverRPC_SpawnDll_Handler,
		},
		{
			MethodName: "Screenshot",
			Handler:    _SliverRPC_Screenshot_Handler,
		},
		{
			MethodName: "CurrentTokenOwner",
			Handler:    _SliverRPC_CurrentTokenOwner_Handler,
		},
		{
			MethodName: "Services",
			Handler:    _SliverRPC_Services_Handler,
		},
		{
			MethodName: "ServiceDetail",
			Handler:    _SliverRPC_ServiceDetail_Handler,
		},
		{
			MethodName: "StartServiceByName",
			Handler:    _SliverRPC_StartServiceByName_Handler,
		},
		{
			MethodName: "PivotStartListener",
			Handler:    _SliverRPC_PivotStartListener_Handler,
		},
		{
			MethodName: "PivotStopListener",
			Handler:    _SliverRPC_PivotStopListener_Handler,
		},
		{
			MethodName: "PivotSessionListeners",
			Handler:    _SliverRPC_PivotSessionListeners_Handler,
		},
		{
			MethodName: "PivotGraph",
			Handler:    _SliverRPC_PivotGraph_Handler,
		},
		{
			MethodName: "StartService",
			Handler:    _SliverRPC_StartService_Handler,
		},
		{
			MethodName: "StopService",
			Handler:    _SliverRPC_StopService_Handler,
		},
		{
			MethodName: "RemoveService",
			Handler:    _SliverRPC_RemoveService_Handler,
		},
		{
			MethodName: "MakeToken",
			Handler:    _SliverRPC_MakeToken_Handler,
		},
		{
			MethodName: "GetEnv",
			Handler:    _SliverRPC_GetEnv_Handler,
		},
		{
			MethodName: "SetEnv",
			Handler:    _SliverRPC_SetEnv_Handler,
		},
		{
			MethodName: "UnsetEnv",
			Handler:    _SliverRPC_UnsetEnv_Handler,
		},
		{
			MethodName: "Backdoor",
			Handler:    _SliverRPC_Backdoor_Handler,
		},
		{
			MethodName: "RegistryRead",
			Handler:    _SliverRPC_RegistryRead_Handler,
		},
		{
			MethodName: "RegistryWrite",
			Handler:    _SliverRPC_RegistryWrite_Handler,
		},
		{
			MethodName: "RegistryCreateKey",
			Handler:    _SliverRPC_RegistryCreateKey_Handler,
		},
		{
			MethodName: "RegistryDeleteKey",
			Handler:    _SliverRPC_RegistryDeleteKey_Handler,
		},
		{
			MethodName: "RegistryListSubKeys",
			Handler:    _SliverRPC_RegistryListSubKeys_Handler,
		},
		{
			MethodName: "RegistryListValues",
			Handler:    _SliverRPC_RegistryListValues_Handler,
		},
		{
			MethodName: "RegistryReadHive",
			Handler:    _SliverRPC_RegistryReadHive_Handler,
		},
		{
			MethodName: "RunSSHCommand",
			Handler:    _SliverRPC_RunSSHCommand_Handler,
		},
		{
			MethodName: "HijackDLL",
			Handler:    _SliverRPC_HijackDLL_Handler,
		},
		{
			MethodName: "GetPrivs",
			Handler:    _SliverRPC_GetPrivs_Handler,
		},
		{
			MethodName: "StartRportFwdListener",
			Handler:    _SliverRPC_StartRportFwdListener_Handler,
		},
		{
			MethodName: "GetRportFwdListeners",
			Handler:    _SliverRPC_GetRportFwdListeners_Handler,
		},
		{
			MethodName: "StopRportFwdListener",
			Handler:    _SliverRPC_StopRportFwdListener_Handler,
		},
		{
			MethodName: "OpenSession",
			Handler:    _SliverRPC_OpenSession_Handler,
		},
		{
			MethodName: "CloseSession",
			Handler:    _SliverRPC_CloseSession_Handler,
		},
		{
			MethodName: "RegisterExtension",
			Handler:    _SliverRPC_RegisterExtension_Handler,
		},
		{
			MethodName: "CallExtension",
			Handler:    _SliverRPC_CallExtension_Handler,
		},
		{
			MethodName: "ListExtensions",
			Handler:    _SliverRPC_ListExtensions_Handler,
		},
		{
			MethodName: "RegisterWasmExtension",
			Handler:    _SliverRPC_RegisterWasmExtension_Handler,
		},
		{
			MethodName: "ListWasmExtensions",
			Handler:    _SliverRPC_ListWasmExtensions_Handler,
		},
		{
			MethodName: "ExecWasmExtension",
			Handler:    _SliverRPC_ExecWasmExtension_Handler,
		},
		{
			MethodName: "WGStartPortForward",
			Handler:    _SliverRPC_WGStartPortForward_Handler,
		},
		{
			MethodName: "WGStopPortForward",
			Handler:    _SliverRPC_WGStopPortForward_Handler,
		},
		{
			MethodName: "WGStartSocks",
			Handler:    _SliverRPC_WGStartSocks_Handler,
		},
		{
			MethodName: "WGStopSocks",
			Handler:    _SliverRPC_WGStopSocks_Handler,
		},
		{
			MethodName: "WGListForwarders",
			Handler:    _SliverRPC_WGListForwarders_Handler,
		},
		{
			MethodName: "WGListSocksServers",
			Handler:    _SliverRPC_WGListSocksServers_Handler,
		},
		{
			MethodName: "Shell",
			Handler:    _SliverRPC_Shell_Handler,
		},
		{
			MethodName: "Portfwd",
			Handler:    _SliverRPC_Portfwd_Handler,
		},
		{
			MethodName: "CreateSocks",
			Handler:    _SliverRPC_CreateSocks_Handler,
		},
		{
			MethodName: "CloseSocks",
			Handler:    _SliverRPC_CloseSocks_Handler,
		},
		{
			MethodName: "CreateTunnel",
			Handler:    _SliverRPC_CreateTunnel_Handler,
		},
		{
			MethodName: "CloseTunnel",
			Handler:    _SliverRPC_CloseTunnel_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ClientLog",
			Handler:       _SliverRPC_ClientLog_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BuilderRegister",
			Handler:       _SliverRPC_BuilderRegister_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CrackstationRegister",
			Handler:       _SliverRPC_CrackstationRegister_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SocksProxy",
			Handler:       _SliverRPC_SocksProxy_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "TunnelData",
			Handler:       _SliverRPC_TunnelData_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Events",
			Handler:       _SliverRPC_Events_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpcpb/services.proto",
}
