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

package listenerrpc

import (
	context "context"
	clientpb "github.com/chainreactors/malice-network/helper/proto/client/clientpb"
	implantpb "github.com/chainreactors/malice-network/helper/proto/implant/implantpb"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

const (
	ListenerRPC_SpiteStream_FullMethodName          = "/listenerrpc.ListenerRPC/SpiteStream"
	ListenerRPC_JobStream_FullMethodName            = "/listenerrpc.ListenerRPC/JobStream"
	ListenerRPC_Register_FullMethodName             = "/listenerrpc.ListenerRPC/Register"
	ListenerRPC_SysInfo_FullMethodName              = "/listenerrpc.ListenerRPC/SysInfo"
	ListenerRPC_Checkin_FullMethodName              = "/listenerrpc.ListenerRPC/Checkin"
	ListenerRPC_InitBindSession_FullMethodName      = "/listenerrpc.ListenerRPC/InitBindSession"
	ListenerRPC_RegisterListener_FullMethodName     = "/listenerrpc.ListenerRPC/RegisterListener"
	ListenerRPC_RegisterPipeline_FullMethodName     = "/listenerrpc.ListenerRPC/RegisterPipeline"
	ListenerRPC_StartPipeline_FullMethodName        = "/listenerrpc.ListenerRPC/StartPipeline"
	ListenerRPC_StopPipeline_FullMethodName         = "/listenerrpc.ListenerRPC/StopPipeline"
	ListenerRPC_DeletePipeline_FullMethodName       = "/listenerrpc.ListenerRPC/DeletePipeline"
	ListenerRPC_ListPipelines_FullMethodName        = "/listenerrpc.ListenerRPC/ListPipelines"
	ListenerRPC_SyncPipeline_FullMethodName         = "/listenerrpc.ListenerRPC/SyncPipeline"
	ListenerRPC_RegisterWebsite_FullMethodName      = "/listenerrpc.ListenerRPC/RegisterWebsite"
	ListenerRPC_StartWebsite_FullMethodName         = "/listenerrpc.ListenerRPC/StartWebsite"
	ListenerRPC_StopWebsite_FullMethodName          = "/listenerrpc.ListenerRPC/StopWebsite"
	ListenerRPC_DeleteWebsite_FullMethodName        = "/listenerrpc.ListenerRPC/DeleteWebsite"
	ListenerRPC_ListWebsites_FullMethodName         = "/listenerrpc.ListenerRPC/ListWebsites"
	ListenerRPC_ListWebContent_FullMethodName       = "/listenerrpc.ListenerRPC/ListWebContent"
	ListenerRPC_AddWebsiteContent_FullMethodName    = "/listenerrpc.ListenerRPC/AddWebsiteContent"
	ListenerRPC_UpdateWebsiteContent_FullMethodName = "/listenerrpc.ListenerRPC/UpdateWebsiteContent"
	ListenerRPC_RemoveWebsiteContent_FullMethodName = "/listenerrpc.ListenerRPC/RemoveWebsiteContent"
	ListenerRPC_RegisterRem_FullMethodName          = "/listenerrpc.ListenerRPC/RegisterRem"
	ListenerRPC_StartRem_FullMethodName             = "/listenerrpc.ListenerRPC/StartRem"
	ListenerRPC_StopRem_FullMethodName              = "/listenerrpc.ListenerRPC/StopRem"
	ListenerRPC_DeleteRem_FullMethodName            = "/listenerrpc.ListenerRPC/DeleteRem"
	ListenerRPC_ListRems_FullMethodName             = "/listenerrpc.ListenerRPC/ListRems"
	ListenerRPC_HealthCheckRem_FullMethodName       = "/listenerrpc.ListenerRPC/HealthCheckRem"
	ListenerRPC_RemAgentCtrl_FullMethodName         = "/listenerrpc.ListenerRPC/RemAgentCtrl"
	ListenerRPC_RemAgentStop_FullMethodName         = "/listenerrpc.ListenerRPC/RemAgentStop"
	ListenerRPC_RemAgentLog_FullMethodName          = "/listenerrpc.ListenerRPC/RemAgentLog"
	ListenerRPC_NewProfile_FullMethodName           = "/listenerrpc.ListenerRPC/NewProfile"
	ListenerRPC_FindArtifact_FullMethodName         = "/listenerrpc.ListenerRPC/FindArtifact"
	ListenerRPC_Build_FullMethodName                = "/listenerrpc.ListenerRPC/Build"
	ListenerRPC_SyncBuild_FullMethodName            = "/listenerrpc.ListenerRPC/SyncBuild"
	ListenerRPC_BuildLog_FullMethodName             = "/listenerrpc.ListenerRPC/BuildLog"
	ListenerRPC_CheckSource_FullMethodName          = "/listenerrpc.ListenerRPC/CheckSource"
	ListenerRPC_GenerateSelfCert_FullMethodName     = "/listenerrpc.ListenerRPC/GenerateSelfCert"
	ListenerRPC_GenerateAcmeCert_FullMethodName     = "/listenerrpc.ListenerRPC/GenerateAcmeCert"
	ListenerRPC_SaveAcmeCert_FullMethodName         = "/listenerrpc.ListenerRPC/SaveAcmeCert"
	ListenerRPC_GetArtifact_FullMethodName          = "/listenerrpc.ListenerRPC/GetArtifact"
)

// ListenerRPCClient is the client API for ListenerRPC 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 ListenerRPCClient interface {
	SpiteStream(ctx context.Context, opts ...grpc.CallOption) (ListenerRPC_SpiteStreamClient, error)
	JobStream(ctx context.Context, opts ...grpc.CallOption) (ListenerRPC_JobStreamClient, error)
	// implant
	Register(ctx context.Context, in *clientpb.RegisterSession, opts ...grpc.CallOption) (*clientpb.Empty, error)
	SysInfo(ctx context.Context, in *implantpb.SysInfo, opts ...grpc.CallOption) (*clientpb.Empty, error)
	Checkin(ctx context.Context, in *implantpb.Ping, opts ...grpc.CallOption) (*clientpb.Empty, error)
	InitBindSession(ctx context.Context, in *implantpb.Request, opts ...grpc.CallOption) (*clientpb.Empty, error)
	// pipeline
	RegisterListener(ctx context.Context, in *clientpb.RegisterListener, opts ...grpc.CallOption) (*clientpb.Empty, error)
	RegisterPipeline(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StartPipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StopPipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	DeletePipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	ListPipelines(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error)
	SyncPipeline(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	// website
	RegisterWebsite(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StartWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StopWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	DeleteWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	ListWebsites(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error)
	ListWebContent(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.WebContents, error)
	AddWebsiteContent(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.WebContent, error)
	UpdateWebsiteContent(ctx context.Context, in *clientpb.WebContent, opts ...grpc.CallOption) (*clientpb.WebContent, error)
	RemoveWebsiteContent(ctx context.Context, in *clientpb.WebContent, opts ...grpc.CallOption) (*clientpb.Empty, error)
	// rem
	RegisterRem(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StartRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	StopRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	DeleteRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	ListRems(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error)
	HealthCheckRem(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	RemAgentCtrl(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.Empty, error)
	RemAgentStop(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.Empty, error)
	RemAgentLog(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.RemLog, error)
	// generator
	NewProfile(ctx context.Context, in *clientpb.Profile, opts ...grpc.CallOption) (*clientpb.Empty, error)
	FindArtifact(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error)
	Build(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.Artifact, error)
	SyncBuild(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.Artifact, error)
	BuildLog(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error)
	CheckSource(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.BuildConfig, error)
	// cert
	GenerateSelfCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	GenerateAcmeCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	SaveAcmeCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error)
	GetArtifact(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error)
}

type listenerRPCClient struct {
	cc grpc.ClientConnInterface
}

func NewListenerRPCClient(cc grpc.ClientConnInterface) ListenerRPCClient {
	return &listenerRPCClient{cc}
}

func (c *listenerRPCClient) SpiteStream(ctx context.Context, opts ...grpc.CallOption) (ListenerRPC_SpiteStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &ListenerRPC_ServiceDesc.Streams[0], ListenerRPC_SpiteStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &listenerRPCSpiteStreamClient{stream}
	return x, nil
}

type ListenerRPC_SpiteStreamClient interface {
	Send(*clientpb.SpiteResponse) error
	Recv() (*clientpb.SpiteRequest, error)
	grpc.ClientStream
}

type listenerRPCSpiteStreamClient struct {
	grpc.ClientStream
}

func (x *listenerRPCSpiteStreamClient) Send(m *clientpb.SpiteResponse) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *listenerRPCClient) JobStream(ctx context.Context, opts ...grpc.CallOption) (ListenerRPC_JobStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &ListenerRPC_ServiceDesc.Streams[1], ListenerRPC_JobStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &listenerRPCJobStreamClient{stream}
	return x, nil
}

type ListenerRPC_JobStreamClient interface {
	Send(*clientpb.JobStatus) error
	Recv() (*clientpb.JobCtrl, error)
	grpc.ClientStream
}

type listenerRPCJobStreamClient struct {
	grpc.ClientStream
}

func (x *listenerRPCJobStreamClient) Send(m *clientpb.JobStatus) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *listenerRPCClient) Register(ctx context.Context, in *clientpb.RegisterSession, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_Register_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) SysInfo(ctx context.Context, in *implantpb.SysInfo, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_SysInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) Checkin(ctx context.Context, in *implantpb.Ping, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_Checkin_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) InitBindSession(ctx context.Context, in *implantpb.Request, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_InitBindSession_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RegisterListener(ctx context.Context, in *clientpb.RegisterListener, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RegisterListener_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RegisterPipeline(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RegisterPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StartPipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StartPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StopPipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StopPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) DeletePipeline(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_DeletePipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) ListPipelines(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error) {
	out := new(clientpb.Pipelines)
	err := c.cc.Invoke(ctx, ListenerRPC_ListPipelines_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) SyncPipeline(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_SyncPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RegisterWebsite(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RegisterWebsite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StartWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StartWebsite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StopWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StopWebsite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) DeleteWebsite(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_DeleteWebsite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) ListWebsites(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error) {
	out := new(clientpb.Pipelines)
	err := c.cc.Invoke(ctx, ListenerRPC_ListWebsites_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) ListWebContent(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.WebContents, error) {
	out := new(clientpb.WebContents)
	err := c.cc.Invoke(ctx, ListenerRPC_ListWebContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) AddWebsiteContent(ctx context.Context, in *clientpb.Website, opts ...grpc.CallOption) (*clientpb.WebContent, error) {
	out := new(clientpb.WebContent)
	err := c.cc.Invoke(ctx, ListenerRPC_AddWebsiteContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) UpdateWebsiteContent(ctx context.Context, in *clientpb.WebContent, opts ...grpc.CallOption) (*clientpb.WebContent, error) {
	out := new(clientpb.WebContent)
	err := c.cc.Invoke(ctx, ListenerRPC_UpdateWebsiteContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RemoveWebsiteContent(ctx context.Context, in *clientpb.WebContent, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RemoveWebsiteContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RegisterRem(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RegisterRem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StartRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StartRem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) StopRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_StopRem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) DeleteRem(ctx context.Context, in *clientpb.CtrlPipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_DeleteRem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) ListRems(ctx context.Context, in *clientpb.Listener, opts ...grpc.CallOption) (*clientpb.Pipelines, error) {
	out := new(clientpb.Pipelines)
	err := c.cc.Invoke(ctx, ListenerRPC_ListRems_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) HealthCheckRem(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_HealthCheckRem_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RemAgentCtrl(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RemAgentCtrl_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RemAgentStop(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_RemAgentStop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) RemAgentLog(ctx context.Context, in *clientpb.REMAgent, opts ...grpc.CallOption) (*clientpb.RemLog, error) {
	out := new(clientpb.RemLog)
	err := c.cc.Invoke(ctx, ListenerRPC_RemAgentLog_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) NewProfile(ctx context.Context, in *clientpb.Profile, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_NewProfile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) FindArtifact(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error) {
	out := new(clientpb.Artifact)
	err := c.cc.Invoke(ctx, ListenerRPC_FindArtifact_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) Build(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.Artifact, error) {
	out := new(clientpb.Artifact)
	err := c.cc.Invoke(ctx, ListenerRPC_Build_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) SyncBuild(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.Artifact, error) {
	out := new(clientpb.Artifact)
	err := c.cc.Invoke(ctx, ListenerRPC_SyncBuild_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) BuildLog(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error) {
	out := new(clientpb.Artifact)
	err := c.cc.Invoke(ctx, ListenerRPC_BuildLog_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) CheckSource(ctx context.Context, in *clientpb.BuildConfig, opts ...grpc.CallOption) (*clientpb.BuildConfig, error) {
	out := new(clientpb.BuildConfig)
	err := c.cc.Invoke(ctx, ListenerRPC_CheckSource_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) GenerateSelfCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_GenerateSelfCert_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) GenerateAcmeCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_GenerateAcmeCert_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) SaveAcmeCert(ctx context.Context, in *clientpb.Pipeline, opts ...grpc.CallOption) (*clientpb.Empty, error) {
	out := new(clientpb.Empty)
	err := c.cc.Invoke(ctx, ListenerRPC_SaveAcmeCert_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *listenerRPCClient) GetArtifact(ctx context.Context, in *clientpb.Artifact, opts ...grpc.CallOption) (*clientpb.Artifact, error) {
	out := new(clientpb.Artifact)
	err := c.cc.Invoke(ctx, ListenerRPC_GetArtifact_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ListenerRPCServer is the server API for ListenerRPC service.
// All implementations must embed UnimplementedListenerRPCServer
// for forward compatibility
type ListenerRPCServer interface {
	SpiteStream(ListenerRPC_SpiteStreamServer) error
	JobStream(ListenerRPC_JobStreamServer) error
	// implant
	Register(context.Context, *clientpb.RegisterSession) (*clientpb.Empty, error)
	SysInfo(context.Context, *implantpb.SysInfo) (*clientpb.Empty, error)
	Checkin(context.Context, *implantpb.Ping) (*clientpb.Empty, error)
	InitBindSession(context.Context, *implantpb.Request) (*clientpb.Empty, error)
	// pipeline
	RegisterListener(context.Context, *clientpb.RegisterListener) (*clientpb.Empty, error)
	RegisterPipeline(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	StartPipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	StopPipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	DeletePipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	ListPipelines(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error)
	SyncPipeline(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	// website
	RegisterWebsite(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	StartWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	StopWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	DeleteWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	ListWebsites(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error)
	ListWebContent(context.Context, *clientpb.Website) (*clientpb.WebContents, error)
	AddWebsiteContent(context.Context, *clientpb.Website) (*clientpb.WebContent, error)
	UpdateWebsiteContent(context.Context, *clientpb.WebContent) (*clientpb.WebContent, error)
	RemoveWebsiteContent(context.Context, *clientpb.WebContent) (*clientpb.Empty, error)
	// rem
	RegisterRem(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	StartRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	StopRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	DeleteRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error)
	ListRems(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error)
	HealthCheckRem(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	RemAgentCtrl(context.Context, *clientpb.REMAgent) (*clientpb.Empty, error)
	RemAgentStop(context.Context, *clientpb.REMAgent) (*clientpb.Empty, error)
	RemAgentLog(context.Context, *clientpb.REMAgent) (*clientpb.RemLog, error)
	// generator
	NewProfile(context.Context, *clientpb.Profile) (*clientpb.Empty, error)
	FindArtifact(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error)
	Build(context.Context, *clientpb.BuildConfig) (*clientpb.Artifact, error)
	SyncBuild(context.Context, *clientpb.BuildConfig) (*clientpb.Artifact, error)
	BuildLog(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error)
	CheckSource(context.Context, *clientpb.BuildConfig) (*clientpb.BuildConfig, error)
	// cert
	GenerateSelfCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	GenerateAcmeCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	SaveAcmeCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error)
	GetArtifact(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error)
	mustEmbedUnimplementedListenerRPCServer()
}

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

func (UnimplementedListenerRPCServer) SpiteStream(ListenerRPC_SpiteStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method SpiteStream not implemented")
}
func (UnimplementedListenerRPCServer) JobStream(ListenerRPC_JobStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method JobStream not implemented")
}
func (UnimplementedListenerRPCServer) Register(context.Context, *clientpb.RegisterSession) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (UnimplementedListenerRPCServer) SysInfo(context.Context, *implantpb.SysInfo) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SysInfo not implemented")
}
func (UnimplementedListenerRPCServer) Checkin(context.Context, *implantpb.Ping) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Checkin not implemented")
}
func (UnimplementedListenerRPCServer) InitBindSession(context.Context, *implantpb.Request) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitBindSession not implemented")
}
func (UnimplementedListenerRPCServer) RegisterListener(context.Context, *clientpb.RegisterListener) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterListener not implemented")
}
func (UnimplementedListenerRPCServer) RegisterPipeline(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterPipeline not implemented")
}
func (UnimplementedListenerRPCServer) StartPipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartPipeline not implemented")
}
func (UnimplementedListenerRPCServer) StopPipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopPipeline not implemented")
}
func (UnimplementedListenerRPCServer) DeletePipeline(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePipeline not implemented")
}
func (UnimplementedListenerRPCServer) ListPipelines(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPipelines not implemented")
}
func (UnimplementedListenerRPCServer) SyncPipeline(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPipeline not implemented")
}
func (UnimplementedListenerRPCServer) RegisterWebsite(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterWebsite not implemented")
}
func (UnimplementedListenerRPCServer) StartWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartWebsite not implemented")
}
func (UnimplementedListenerRPCServer) StopWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopWebsite not implemented")
}
func (UnimplementedListenerRPCServer) DeleteWebsite(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteWebsite not implemented")
}
func (UnimplementedListenerRPCServer) ListWebsites(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWebsites not implemented")
}
func (UnimplementedListenerRPCServer) ListWebContent(context.Context, *clientpb.Website) (*clientpb.WebContents, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWebContent not implemented")
}
func (UnimplementedListenerRPCServer) AddWebsiteContent(context.Context, *clientpb.Website) (*clientpb.WebContent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddWebsiteContent not implemented")
}
func (UnimplementedListenerRPCServer) UpdateWebsiteContent(context.Context, *clientpb.WebContent) (*clientpb.WebContent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateWebsiteContent not implemented")
}
func (UnimplementedListenerRPCServer) RemoveWebsiteContent(context.Context, *clientpb.WebContent) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveWebsiteContent not implemented")
}
func (UnimplementedListenerRPCServer) RegisterRem(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterRem not implemented")
}
func (UnimplementedListenerRPCServer) StartRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartRem not implemented")
}
func (UnimplementedListenerRPCServer) StopRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopRem not implemented")
}
func (UnimplementedListenerRPCServer) DeleteRem(context.Context, *clientpb.CtrlPipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRem not implemented")
}
func (UnimplementedListenerRPCServer) ListRems(context.Context, *clientpb.Listener) (*clientpb.Pipelines, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRems not implemented")
}
func (UnimplementedListenerRPCServer) HealthCheckRem(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HealthCheckRem not implemented")
}
func (UnimplementedListenerRPCServer) RemAgentCtrl(context.Context, *clientpb.REMAgent) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemAgentCtrl not implemented")
}
func (UnimplementedListenerRPCServer) RemAgentStop(context.Context, *clientpb.REMAgent) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemAgentStop not implemented")
}
func (UnimplementedListenerRPCServer) RemAgentLog(context.Context, *clientpb.REMAgent) (*clientpb.RemLog, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemAgentLog not implemented")
}
func (UnimplementedListenerRPCServer) NewProfile(context.Context, *clientpb.Profile) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewProfile not implemented")
}
func (UnimplementedListenerRPCServer) FindArtifact(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindArtifact not implemented")
}
func (UnimplementedListenerRPCServer) Build(context.Context, *clientpb.BuildConfig) (*clientpb.Artifact, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Build not implemented")
}
func (UnimplementedListenerRPCServer) SyncBuild(context.Context, *clientpb.BuildConfig) (*clientpb.Artifact, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncBuild not implemented")
}
func (UnimplementedListenerRPCServer) BuildLog(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BuildLog not implemented")
}
func (UnimplementedListenerRPCServer) CheckSource(context.Context, *clientpb.BuildConfig) (*clientpb.BuildConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckSource not implemented")
}
func (UnimplementedListenerRPCServer) GenerateSelfCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateSelfCert not implemented")
}
func (UnimplementedListenerRPCServer) GenerateAcmeCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateAcmeCert not implemented")
}
func (UnimplementedListenerRPCServer) SaveAcmeCert(context.Context, *clientpb.Pipeline) (*clientpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveAcmeCert not implemented")
}
func (UnimplementedListenerRPCServer) GetArtifact(context.Context, *clientpb.Artifact) (*clientpb.Artifact, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetArtifact not implemented")
}
func (UnimplementedListenerRPCServer) mustEmbedUnimplementedListenerRPCServer() {}

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

func RegisterListenerRPCServer(s grpc.ServiceRegistrar, srv ListenerRPCServer) {
	s.RegisterService(&ListenerRPC_ServiceDesc, srv)
}

func _ListenerRPC_SpiteStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ListenerRPCServer).SpiteStream(&listenerRPCSpiteStreamServer{stream})
}

type ListenerRPC_SpiteStreamServer interface {
	Send(*clientpb.SpiteRequest) error
	Recv() (*clientpb.SpiteResponse, error)
	grpc.ServerStream
}

type listenerRPCSpiteStreamServer struct {
	grpc.ServerStream
}

func (x *listenerRPCSpiteStreamServer) Send(m *clientpb.SpiteRequest) error {
	return x.ServerStream.SendMsg(m)
}

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

func _ListenerRPC_JobStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ListenerRPCServer).JobStream(&listenerRPCJobStreamServer{stream})
}

type ListenerRPC_JobStreamServer interface {
	Send(*clientpb.JobCtrl) error
	Recv() (*clientpb.JobStatus, error)
	grpc.ServerStream
}

type listenerRPCJobStreamServer struct {
	grpc.ServerStream
}

func (x *listenerRPCJobStreamServer) Send(m *clientpb.JobCtrl) error {
	return x.ServerStream.SendMsg(m)
}

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

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

func _ListenerRPC_SysInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(implantpb.SysInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ListenerRPCServer).SysInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ListenerRPC_SysInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ListenerRPCServer).SysInfo(ctx, req.(*implantpb.SysInfo))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _ListenerRPC_InitBindSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(implantpb.Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ListenerRPCServer).InitBindSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ListenerRPC_InitBindSession_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ListenerRPCServer).InitBindSession(ctx, req.(*implantpb.Request))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

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

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

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

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

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

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

func _ListenerRPC_ListWebContent_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.(ListenerRPCServer).ListWebContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ListenerRPC_ListWebContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ListenerRPCServer).ListWebContent(ctx, req.(*clientpb.Website))
	}
	return interceptor(ctx, in, info, handler)
}

func _ListenerRPC_AddWebsiteContent_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.(ListenerRPCServer).AddWebsiteContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ListenerRPC_AddWebsiteContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ListenerRPCServer).AddWebsiteContent(ctx, req.(*clientpb.Website))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListenerRPC_ServiceDesc is the grpc.ServiceDesc for ListenerRPC service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ListenerRPC_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "listenerrpc.ListenerRPC",
	HandlerType: (*ListenerRPCServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Register",
			Handler:    _ListenerRPC_Register_Handler,
		},
		{
			MethodName: "SysInfo",
			Handler:    _ListenerRPC_SysInfo_Handler,
		},
		{
			MethodName: "Checkin",
			Handler:    _ListenerRPC_Checkin_Handler,
		},
		{
			MethodName: "InitBindSession",
			Handler:    _ListenerRPC_InitBindSession_Handler,
		},
		{
			MethodName: "RegisterListener",
			Handler:    _ListenerRPC_RegisterListener_Handler,
		},
		{
			MethodName: "RegisterPipeline",
			Handler:    _ListenerRPC_RegisterPipeline_Handler,
		},
		{
			MethodName: "StartPipeline",
			Handler:    _ListenerRPC_StartPipeline_Handler,
		},
		{
			MethodName: "StopPipeline",
			Handler:    _ListenerRPC_StopPipeline_Handler,
		},
		{
			MethodName: "DeletePipeline",
			Handler:    _ListenerRPC_DeletePipeline_Handler,
		},
		{
			MethodName: "ListPipelines",
			Handler:    _ListenerRPC_ListPipelines_Handler,
		},
		{
			MethodName: "SyncPipeline",
			Handler:    _ListenerRPC_SyncPipeline_Handler,
		},
		{
			MethodName: "RegisterWebsite",
			Handler:    _ListenerRPC_RegisterWebsite_Handler,
		},
		{
			MethodName: "StartWebsite",
			Handler:    _ListenerRPC_StartWebsite_Handler,
		},
		{
			MethodName: "StopWebsite",
			Handler:    _ListenerRPC_StopWebsite_Handler,
		},
		{
			MethodName: "DeleteWebsite",
			Handler:    _ListenerRPC_DeleteWebsite_Handler,
		},
		{
			MethodName: "ListWebsites",
			Handler:    _ListenerRPC_ListWebsites_Handler,
		},
		{
			MethodName: "ListWebContent",
			Handler:    _ListenerRPC_ListWebContent_Handler,
		},
		{
			MethodName: "AddWebsiteContent",
			Handler:    _ListenerRPC_AddWebsiteContent_Handler,
		},
		{
			MethodName: "UpdateWebsiteContent",
			Handler:    _ListenerRPC_UpdateWebsiteContent_Handler,
		},
		{
			MethodName: "RemoveWebsiteContent",
			Handler:    _ListenerRPC_RemoveWebsiteContent_Handler,
		},
		{
			MethodName: "RegisterRem",
			Handler:    _ListenerRPC_RegisterRem_Handler,
		},
		{
			MethodName: "StartRem",
			Handler:    _ListenerRPC_StartRem_Handler,
		},
		{
			MethodName: "StopRem",
			Handler:    _ListenerRPC_StopRem_Handler,
		},
		{
			MethodName: "DeleteRem",
			Handler:    _ListenerRPC_DeleteRem_Handler,
		},
		{
			MethodName: "ListRems",
			Handler:    _ListenerRPC_ListRems_Handler,
		},
		{
			MethodName: "HealthCheckRem",
			Handler:    _ListenerRPC_HealthCheckRem_Handler,
		},
		{
			MethodName: "RemAgentCtrl",
			Handler:    _ListenerRPC_RemAgentCtrl_Handler,
		},
		{
			MethodName: "RemAgentStop",
			Handler:    _ListenerRPC_RemAgentStop_Handler,
		},
		{
			MethodName: "RemAgentLog",
			Handler:    _ListenerRPC_RemAgentLog_Handler,
		},
		{
			MethodName: "NewProfile",
			Handler:    _ListenerRPC_NewProfile_Handler,
		},
		{
			MethodName: "FindArtifact",
			Handler:    _ListenerRPC_FindArtifact_Handler,
		},
		{
			MethodName: "Build",
			Handler:    _ListenerRPC_Build_Handler,
		},
		{
			MethodName: "SyncBuild",
			Handler:    _ListenerRPC_SyncBuild_Handler,
		},
		{
			MethodName: "BuildLog",
			Handler:    _ListenerRPC_BuildLog_Handler,
		},
		{
			MethodName: "CheckSource",
			Handler:    _ListenerRPC_CheckSource_Handler,
		},
		{
			MethodName: "GenerateSelfCert",
			Handler:    _ListenerRPC_GenerateSelfCert_Handler,
		},
		{
			MethodName: "GenerateAcmeCert",
			Handler:    _ListenerRPC_GenerateAcmeCert_Handler,
		},
		{
			MethodName: "SaveAcmeCert",
			Handler:    _ListenerRPC_SaveAcmeCert_Handler,
		},
		{
			MethodName: "GetArtifact",
			Handler:    _ListenerRPC_GetArtifact_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SpiteStream",
			Handler:       _ListenerRPC_SpiteStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "JobStream",
			Handler:       _ListenerRPC_JobStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "services/listenerrpc/service.proto",
}
