bldr/plugin/plugin_srpc.pb.go

Rama master · réplica de lectura del repositorio original.

// Code generated by protoc-gen-srpc. DO NOT EDIT.
// protoc-gen-srpc version: v0.52.4-0.20261024233818-0a9074172c29
// source: github.com/s4wave/spacewave/bldr/plugin/plugin.proto

package bldr_plugin

import (
	context "context"

	controller_exec "github.com/aperturerobotics/controllerbus/controller/exec"
	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
	srpc "github.com/aperturerobotics/starpc/srpc"
)

type SRPCPluginHostClient interface {
	// SRPCClient returns the underlying SRPC client.
	SRPCClient() srpc.Client

	// GetPluginInfo returns the information for the current plugin.
	GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest) (*GetPluginInfoResponse, error)
	// ExecController executes a controller configuration on the bus.
	ExecController(ctx context.Context, in *controller_exec.ExecControllerRequest) (SRPCPluginHost_ExecControllerClient, error)
	// LoadPlugin requests to load the plugin with the given ID.
	// The plugin will remain loaded as long as the RPC is active.
	// Multiple requests to load the same plugin are de-duplicated.
	LoadPlugin(ctx context.Context, in *LoadPluginRequest) (SRPCPluginHost_LoadPluginClient, error)
	// PluginRpc forwards an RPC call to a remote plugin.
	// The plugin will remain loaded as long as the RPC is active.
	// Component ID: plugin id, or plugin id / instance key for instanced plugins.
	PluginRpc(ctx context.Context) (SRPCPluginHost_PluginRpcClient, error)
	// PluginFsRpc accesses a FSCursorService to access plugin assets or dist filesystems.
	// The plugin will remain loaded as long as the RPC is active.
	// Component ID: plugin-assets or plugin-dist for current plugin
	// Component ID: plugin-assets/{plugin-id} or plugin-dist/{plugin-id} for remote plugin
	PluginFsRpc(ctx context.Context) (SRPCPluginHost_PluginFsRpcClient, error)
	// WatchPluginStatus streams the host scheduler's plugin status.
	// Sends the current snapshot, then each change.
	WatchPluginStatus(ctx context.Context, in *WatchPluginStatusRequest) (SRPCPluginHost_WatchPluginStatusClient, error)
}

type srpcPluginHostClient struct {
	cc        srpc.Client
	serviceID string
}

func NewSRPCPluginHostClient(cc srpc.Client) SRPCPluginHostClient {
	return &srpcPluginHostClient{cc: cc, serviceID: SRPCPluginHostServiceID}
}

func NewSRPCPluginHostClientWithServiceID(cc srpc.Client, serviceID string) SRPCPluginHostClient {
	if serviceID == "" {
		serviceID = SRPCPluginHostServiceID
	}
	return &srpcPluginHostClient{cc: cc, serviceID: serviceID}
}

func (c *srpcPluginHostClient) SRPCClient() srpc.Client { return c.cc }

func (c *srpcPluginHostClient) GetPluginInfo(ctx context.Context, in *GetPluginInfoRequest) (*GetPluginInfoResponse, error) {
	out := new(GetPluginInfoResponse)
	err := c.cc.ExecCall(ctx, c.serviceID, "GetPluginInfo", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *srpcPluginHostClient) ExecController(ctx context.Context, in *controller_exec.ExecControllerRequest) (SRPCPluginHost_ExecControllerClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "ExecController", in)
	if err != nil {
		return nil, err
	}
	strm := &srpcPluginHost_ExecControllerClient{stream}
	// A failed half-close means the call ended; MsgRecv reports its outcome.
	_ = strm.CloseSend()
	return strm, nil
}

type SRPCPluginHost_ExecControllerClient interface {
	srpc.Stream
	Recv() (*controller_exec.ExecControllerResponse, error)
	RecvTo(*controller_exec.ExecControllerResponse) error
}

type srpcPluginHost_ExecControllerClient struct {
	srpc.Stream
}

func (x *srpcPluginHost_ExecControllerClient) Recv() (*controller_exec.ExecControllerResponse, error) {
	m := new(controller_exec.ExecControllerResponse)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_ExecControllerClient) RecvTo(m *controller_exec.ExecControllerResponse) error {
	return x.MsgRecv(m)
}

func (c *srpcPluginHostClient) LoadPlugin(ctx context.Context, in *LoadPluginRequest) (SRPCPluginHost_LoadPluginClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "LoadPlugin", in)
	if err != nil {
		return nil, err
	}
	strm := &srpcPluginHost_LoadPluginClient{stream}
	// A failed half-close means the call ended; MsgRecv reports its outcome.
	_ = strm.CloseSend()
	return strm, nil
}

type SRPCPluginHost_LoadPluginClient interface {
	srpc.Stream
	Recv() (*LoadPluginResponse, error)
	RecvTo(*LoadPluginResponse) error
}

type srpcPluginHost_LoadPluginClient struct {
	srpc.Stream
}

func (x *srpcPluginHost_LoadPluginClient) Recv() (*LoadPluginResponse, error) {
	m := new(LoadPluginResponse)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_LoadPluginClient) RecvTo(m *LoadPluginResponse) error {
	return x.MsgRecv(m)
}

func (c *srpcPluginHostClient) PluginRpc(ctx context.Context) (SRPCPluginHost_PluginRpcClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "PluginRpc", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcPluginHost_PluginRpcClient{stream}
	return strm, nil
}

type SRPCPluginHost_PluginRpcClient interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPluginHost_PluginRpcClient struct {
	srpc.Stream
}

func (x *srpcPluginHost_PluginRpcClient) Send(m *rpcstream.RpcStreamPacket) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcPluginHost_PluginRpcClient) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_PluginRpcClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

func (c *srpcPluginHostClient) PluginFsRpc(ctx context.Context) (SRPCPluginHost_PluginFsRpcClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "PluginFsRpc", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcPluginHost_PluginFsRpcClient{stream}
	return strm, nil
}

type SRPCPluginHost_PluginFsRpcClient interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPluginHost_PluginFsRpcClient struct {
	srpc.Stream
}

func (x *srpcPluginHost_PluginFsRpcClient) Send(m *rpcstream.RpcStreamPacket) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcPluginHost_PluginFsRpcClient) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_PluginFsRpcClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

func (c *srpcPluginHostClient) WatchPluginStatus(ctx context.Context, in *WatchPluginStatusRequest) (SRPCPluginHost_WatchPluginStatusClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "WatchPluginStatus", in)
	if err != nil {
		return nil, err
	}
	strm := &srpcPluginHost_WatchPluginStatusClient{stream}
	// A failed half-close means the call ended; MsgRecv reports its outcome.
	_ = strm.CloseSend()
	return strm, nil
}

type SRPCPluginHost_WatchPluginStatusClient interface {
	srpc.Stream
	Recv() (*WatchPluginStatusResponse, error)
	RecvTo(*WatchPluginStatusResponse) error
}

type srpcPluginHost_WatchPluginStatusClient struct {
	srpc.Stream
}

func (x *srpcPluginHost_WatchPluginStatusClient) Recv() (*WatchPluginStatusResponse, error) {
	m := new(WatchPluginStatusResponse)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_WatchPluginStatusClient) RecvTo(m *WatchPluginStatusResponse) error {
	return x.MsgRecv(m)
}

type SRPCPluginHostServer interface {
	// GetPluginInfo returns the information for the current plugin.
	GetPluginInfo(context.Context, *GetPluginInfoRequest) (*GetPluginInfoResponse, error)
	// ExecController executes a controller configuration on the bus.
	ExecController(*controller_exec.ExecControllerRequest, SRPCPluginHost_ExecControllerStream) error
	// LoadPlugin requests to load the plugin with the given ID.
	// The plugin will remain loaded as long as the RPC is active.
	// Multiple requests to load the same plugin are de-duplicated.
	LoadPlugin(*LoadPluginRequest, SRPCPluginHost_LoadPluginStream) error
	// PluginRpc forwards an RPC call to a remote plugin.
	// The plugin will remain loaded as long as the RPC is active.
	// Component ID: plugin id, or plugin id / instance key for instanced plugins.
	PluginRpc(SRPCPluginHost_PluginRpcStream) error
	// PluginFsRpc accesses a FSCursorService to access plugin assets or dist filesystems.
	// The plugin will remain loaded as long as the RPC is active.
	// Component ID: plugin-assets or plugin-dist for current plugin
	// Component ID: plugin-assets/{plugin-id} or plugin-dist/{plugin-id} for remote plugin
	PluginFsRpc(SRPCPluginHost_PluginFsRpcStream) error
	// WatchPluginStatus streams the host scheduler's plugin status.
	// Sends the current snapshot, then each change.
	WatchPluginStatus(*WatchPluginStatusRequest, SRPCPluginHost_WatchPluginStatusStream) error
}

const SRPCPluginHostServiceID = "bldr.plugin.PluginHost"

type SRPCPluginHostHandler struct {
	serviceID string
	impl      SRPCPluginHostServer
}

// NewSRPCPluginHostHandler constructs a new RPC handler.
// serviceID: if empty, uses default: bldr.plugin.PluginHost
func NewSRPCPluginHostHandler(impl SRPCPluginHostServer, serviceID string) srpc.Handler {
	if serviceID == "" {
		serviceID = SRPCPluginHostServiceID
	}
	return &SRPCPluginHostHandler{impl: impl, serviceID: serviceID}
}

// SRPCRegisterPluginHost registers the implementation with the mux.
// Uses the default serviceID: bldr.plugin.PluginHost
func SRPCRegisterPluginHost(mux srpc.Mux, impl SRPCPluginHostServer) error {
	return mux.Register(NewSRPCPluginHostHandler(impl, ""))
}

func (d *SRPCPluginHostHandler) GetServiceID() string { return d.serviceID }

func (SRPCPluginHostHandler) GetMethodIDs() []string {
	return []string{
		"GetPluginInfo",
		"ExecController",
		"LoadPlugin",
		"PluginRpc",
		"PluginFsRpc",
		"WatchPluginStatus",
	}
}

func (d *SRPCPluginHostHandler) InvokeMethod(
	serviceID, methodID string,
	strm srpc.Stream,
) (bool, error) {
	if serviceID != "" && serviceID != d.GetServiceID() {
		return false, nil
	}

	switch methodID {
	case "GetPluginInfo":
		return true, d.InvokeMethod_GetPluginInfo(d.impl, strm)
	case "ExecController":
		return true, d.InvokeMethod_ExecController(d.impl, strm)
	case "LoadPlugin":
		return true, d.InvokeMethod_LoadPlugin(d.impl, strm)
	case "PluginRpc":
		return true, d.InvokeMethod_PluginRpc(d.impl, strm)
	case "PluginFsRpc":
		return true, d.InvokeMethod_PluginFsRpc(d.impl, strm)
	case "WatchPluginStatus":
		return true, d.InvokeMethod_WatchPluginStatus(d.impl, strm)
	default:
		return false, nil
	}
}

func (SRPCPluginHostHandler) InvokeMethod_GetPluginInfo(impl SRPCPluginHostServer, strm srpc.Stream) error {
	req := new(GetPluginInfoRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	out, err := impl.GetPluginInfo(strm.Context(), req)
	if err != nil {
		return err
	}
	return strm.MsgSend(out)
}

func (SRPCPluginHostHandler) InvokeMethod_ExecController(impl SRPCPluginHostServer, strm srpc.Stream) error {
	req := new(controller_exec.ExecControllerRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	serverStrm := &srpcPluginHost_ExecControllerStream{strm}
	return impl.ExecController(req, serverStrm)
}

func (SRPCPluginHostHandler) InvokeMethod_LoadPlugin(impl SRPCPluginHostServer, strm srpc.Stream) error {
	req := new(LoadPluginRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	serverStrm := &srpcPluginHost_LoadPluginStream{strm}
	return impl.LoadPlugin(req, serverStrm)
}

func (SRPCPluginHostHandler) InvokeMethod_PluginRpc(impl SRPCPluginHostServer, strm srpc.Stream) error {
	clientStrm := &srpcPluginHost_PluginRpcStream{strm}
	return impl.PluginRpc(clientStrm)
}

func (SRPCPluginHostHandler) InvokeMethod_PluginFsRpc(impl SRPCPluginHostServer, strm srpc.Stream) error {
	clientStrm := &srpcPluginHost_PluginFsRpcStream{strm}
	return impl.PluginFsRpc(clientStrm)
}

func (SRPCPluginHostHandler) InvokeMethod_WatchPluginStatus(impl SRPCPluginHostServer, strm srpc.Stream) error {
	req := new(WatchPluginStatusRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	serverStrm := &srpcPluginHost_WatchPluginStatusStream{strm}
	return impl.WatchPluginStatus(req, serverStrm)
}

type SRPCPluginHost_GetPluginInfoStream interface {
	srpc.Stream
}

type srpcPluginHost_GetPluginInfoStream struct {
	srpc.Stream
}

type SRPCPluginHost_ExecControllerStream interface {
	srpc.Stream
	Send(*controller_exec.ExecControllerResponse) error
	SendAndClose(*controller_exec.ExecControllerResponse) error
}

type srpcPluginHost_ExecControllerStream struct {
	srpc.Stream
}

func (x *srpcPluginHost_ExecControllerStream) Send(m *controller_exec.ExecControllerResponse) error {
	return x.MsgSend(m)
}

func (x *srpcPluginHost_ExecControllerStream) SendAndClose(m *controller_exec.ExecControllerResponse) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

type SRPCPluginHost_LoadPluginStream interface {
	srpc.Stream
	Send(*LoadPluginResponse) error
	SendAndClose(*LoadPluginResponse) error
}

type srpcPluginHost_LoadPluginStream struct {
	srpc.Stream
}

func (x *srpcPluginHost_LoadPluginStream) Send(m *LoadPluginResponse) error {
	return x.MsgSend(m)
}

func (x *srpcPluginHost_LoadPluginStream) SendAndClose(m *LoadPluginResponse) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

type SRPCPluginHost_PluginRpcStream interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	SendAndClose(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPluginHost_PluginRpcStream struct {
	srpc.Stream
}

func (x *srpcPluginHost_PluginRpcStream) Send(m *rpcstream.RpcStreamPacket) error {
	return x.MsgSend(m)
}

func (x *srpcPluginHost_PluginRpcStream) SendAndClose(m *rpcstream.RpcStreamPacket) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcPluginHost_PluginRpcStream) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_PluginRpcStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

type SRPCPluginHost_PluginFsRpcStream interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	SendAndClose(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPluginHost_PluginFsRpcStream struct {
	srpc.Stream
}

func (x *srpcPluginHost_PluginFsRpcStream) Send(m *rpcstream.RpcStreamPacket) error {
	return x.MsgSend(m)
}

func (x *srpcPluginHost_PluginFsRpcStream) SendAndClose(m *rpcstream.RpcStreamPacket) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcPluginHost_PluginFsRpcStream) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPluginHost_PluginFsRpcStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

type SRPCPluginHost_WatchPluginStatusStream interface {
	srpc.Stream
	Send(*WatchPluginStatusResponse) error
	SendAndClose(*WatchPluginStatusResponse) error
}

type srpcPluginHost_WatchPluginStatusStream struct {
	srpc.Stream
}

func (x *srpcPluginHost_WatchPluginStatusStream) Send(m *WatchPluginStatusResponse) error {
	return x.MsgSend(m)
}

func (x *srpcPluginHost_WatchPluginStatusStream) SendAndClose(m *WatchPluginStatusResponse) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

type SRPCPluginClient interface {
	// SRPCClient returns the underlying SRPC client.
	SRPCClient() srpc.Client

	// PluginRpc handles an RPC call from a remote plugin.
	// Component ID: remote plugin id
	PluginRpc(ctx context.Context) (SRPCPlugin_PluginRpcClient, error)
}

type srpcPluginClient struct {
	cc        srpc.Client
	serviceID string
}

func NewSRPCPluginClient(cc srpc.Client) SRPCPluginClient {
	return &srpcPluginClient{cc: cc, serviceID: SRPCPluginServiceID}
}

func NewSRPCPluginClientWithServiceID(cc srpc.Client, serviceID string) SRPCPluginClient {
	if serviceID == "" {
		serviceID = SRPCPluginServiceID
	}
	return &srpcPluginClient{cc: cc, serviceID: serviceID}
}

func (c *srpcPluginClient) SRPCClient() srpc.Client { return c.cc }

func (c *srpcPluginClient) PluginRpc(ctx context.Context) (SRPCPlugin_PluginRpcClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "PluginRpc", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcPlugin_PluginRpcClient{stream}
	return strm, nil
}

type SRPCPlugin_PluginRpcClient interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPlugin_PluginRpcClient struct {
	srpc.Stream
}

func (x *srpcPlugin_PluginRpcClient) Send(m *rpcstream.RpcStreamPacket) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcPlugin_PluginRpcClient) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPlugin_PluginRpcClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

type SRPCPluginServer interface {
	// PluginRpc handles an RPC call from a remote plugin.
	// Component ID: remote plugin id
	PluginRpc(SRPCPlugin_PluginRpcStream) error
}

const SRPCPluginServiceID = "bldr.plugin.Plugin"

type SRPCPluginHandler struct {
	serviceID string
	impl      SRPCPluginServer
}

// NewSRPCPluginHandler constructs a new RPC handler.
// serviceID: if empty, uses default: bldr.plugin.Plugin
func NewSRPCPluginHandler(impl SRPCPluginServer, serviceID string) srpc.Handler {
	if serviceID == "" {
		serviceID = SRPCPluginServiceID
	}
	return &SRPCPluginHandler{impl: impl, serviceID: serviceID}
}

// SRPCRegisterPlugin registers the implementation with the mux.
// Uses the default serviceID: bldr.plugin.Plugin
func SRPCRegisterPlugin(mux srpc.Mux, impl SRPCPluginServer) error {
	return mux.Register(NewSRPCPluginHandler(impl, ""))
}

func (d *SRPCPluginHandler) GetServiceID() string { return d.serviceID }

func (SRPCPluginHandler) GetMethodIDs() []string {
	return []string{
		"PluginRpc",
	}
}

func (d *SRPCPluginHandler) InvokeMethod(
	serviceID, methodID string,
	strm srpc.Stream,
) (bool, error) {
	if serviceID != "" && serviceID != d.GetServiceID() {
		return false, nil
	}

	switch methodID {
	case "PluginRpc":
		return true, d.InvokeMethod_PluginRpc(d.impl, strm)
	default:
		return false, nil
	}
}

func (SRPCPluginHandler) InvokeMethod_PluginRpc(impl SRPCPluginServer, strm srpc.Stream) error {
	clientStrm := &srpcPlugin_PluginRpcStream{strm}
	return impl.PluginRpc(clientStrm)
}

type SRPCPlugin_PluginRpcStream interface {
	srpc.Stream
	Send(*rpcstream.RpcStreamPacket) error
	SendAndClose(*rpcstream.RpcStreamPacket) error
	Recv() (*rpcstream.RpcStreamPacket, error)
	RecvTo(*rpcstream.RpcStreamPacket) error
}

type srpcPlugin_PluginRpcStream struct {
	srpc.Stream
}

func (x *srpcPlugin_PluginRpcStream) Send(m *rpcstream.RpcStreamPacket) error {
	return x.MsgSend(m)
}

func (x *srpcPlugin_PluginRpcStream) SendAndClose(m *rpcstream.RpcStreamPacket) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcPlugin_PluginRpcStream) Recv() (*rpcstream.RpcStreamPacket, error) {
	m := new(rpcstream.RpcStreamPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcPlugin_PluginRpcStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
	return x.MsgRecv(m)
}

type SRPCUpdateGuardClient interface {
	// SRPCClient returns the underlying SRPC client.
	SRPCClient() srpc.Client

	// Prepare waits for owned work to finish and prevents new work from starting.
	// Success authorizes replacement of this plugin generation.
	Prepare(ctx context.Context, in *PrepareUpdateRequest) (*PrepareUpdateResponse, error)
}

type srpcUpdateGuardClient struct {
	cc        srpc.Client
	serviceID string
}

func NewSRPCUpdateGuardClient(cc srpc.Client) SRPCUpdateGuardClient {
	return &srpcUpdateGuardClient{cc: cc, serviceID: SRPCUpdateGuardServiceID}
}

func NewSRPCUpdateGuardClientWithServiceID(cc srpc.Client, serviceID string) SRPCUpdateGuardClient {
	if serviceID == "" {
		serviceID = SRPCUpdateGuardServiceID
	}
	return &srpcUpdateGuardClient{cc: cc, serviceID: serviceID}
}

func (c *srpcUpdateGuardClient) SRPCClient() srpc.Client { return c.cc }

func (c *srpcUpdateGuardClient) Prepare(ctx context.Context, in *PrepareUpdateRequest) (*PrepareUpdateResponse, error) {
	out := new(PrepareUpdateResponse)
	err := c.cc.ExecCall(ctx, c.serviceID, "Prepare", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type SRPCUpdateGuardServer interface {
	// Prepare waits for owned work to finish and prevents new work from starting.
	// Success authorizes replacement of this plugin generation.
	Prepare(context.Context, *PrepareUpdateRequest) (*PrepareUpdateResponse, error)
}

const SRPCUpdateGuardServiceID = "bldr.plugin.UpdateGuard"

type SRPCUpdateGuardHandler struct {
	serviceID string
	impl      SRPCUpdateGuardServer
}

// NewSRPCUpdateGuardHandler constructs a new RPC handler.
// serviceID: if empty, uses default: bldr.plugin.UpdateGuard
func NewSRPCUpdateGuardHandler(impl SRPCUpdateGuardServer, serviceID string) srpc.Handler {
	if serviceID == "" {
		serviceID = SRPCUpdateGuardServiceID
	}
	return &SRPCUpdateGuardHandler{impl: impl, serviceID: serviceID}
}

// SRPCRegisterUpdateGuard registers the implementation with the mux.
// Uses the default serviceID: bldr.plugin.UpdateGuard
func SRPCRegisterUpdateGuard(mux srpc.Mux, impl SRPCUpdateGuardServer) error {
	return mux.Register(NewSRPCUpdateGuardHandler(impl, ""))
}

func (d *SRPCUpdateGuardHandler) GetServiceID() string { return d.serviceID }

func (SRPCUpdateGuardHandler) GetMethodIDs() []string {
	return []string{
		"Prepare",
	}
}

func (d *SRPCUpdateGuardHandler) InvokeMethod(
	serviceID, methodID string,
	strm srpc.Stream,
) (bool, error) {
	if serviceID != "" && serviceID != d.GetServiceID() {
		return false, nil
	}

	switch methodID {
	case "Prepare":
		return true, d.InvokeMethod_Prepare(d.impl, strm)
	default:
		return false, nil
	}
}

func (SRPCUpdateGuardHandler) InvokeMethod_Prepare(impl SRPCUpdateGuardServer, strm srpc.Stream) error {
	req := new(PrepareUpdateRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	out, err := impl.Prepare(strm.Context(), req)
	if err != nil {
		return err
	}
	return strm.MsgSend(out)
}

type SRPCUpdateGuard_PrepareStream interface {
	srpc.Stream
}

type srpcUpdateGuard_PrepareStream struct {
	srpc.Stream
}

type SRPCActivationClient interface {
	// SRPCClient returns the underlying SRPC client.
	SRPCClient() srpc.Client

	// Check confirms support for private startup and atomic registration admission.
	Check(ctx context.Context, in *CheckActivationRequest) (*CheckActivationResponse, error)
	// Activate admits this worker's prepared registrations after startup succeeds.
	Activate(ctx context.Context, in *ActivatePluginRequest) (*ActivatePluginResponse, error)
}

type srpcActivationClient struct {
	cc        srpc.Client
	serviceID string
}

func NewSRPCActivationClient(cc srpc.Client) SRPCActivationClient {
	return &srpcActivationClient{cc: cc, serviceID: SRPCActivationServiceID}
}

func NewSRPCActivationClientWithServiceID(cc srpc.Client, serviceID string) SRPCActivationClient {
	if serviceID == "" {
		serviceID = SRPCActivationServiceID
	}
	return &srpcActivationClient{cc: cc, serviceID: serviceID}
}

func (c *srpcActivationClient) SRPCClient() srpc.Client { return c.cc }

func (c *srpcActivationClient) Check(ctx context.Context, in *CheckActivationRequest) (*CheckActivationResponse, error) {
	out := new(CheckActivationResponse)
	err := c.cc.ExecCall(ctx, c.serviceID, "Check", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *srpcActivationClient) Activate(ctx context.Context, in *ActivatePluginRequest) (*ActivatePluginResponse, error) {
	out := new(ActivatePluginResponse)
	err := c.cc.ExecCall(ctx, c.serviceID, "Activate", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type SRPCActivationServer interface {
	// Check confirms support for private startup and atomic registration admission.
	Check(context.Context, *CheckActivationRequest) (*CheckActivationResponse, error)
	// Activate admits this worker's prepared registrations after startup succeeds.
	Activate(context.Context, *ActivatePluginRequest) (*ActivatePluginResponse, error)
}

const SRPCActivationServiceID = "bldr.plugin.Activation"

type SRPCActivationHandler struct {
	serviceID string
	impl      SRPCActivationServer
}

// NewSRPCActivationHandler constructs a new RPC handler.
// serviceID: if empty, uses default: bldr.plugin.Activation
func NewSRPCActivationHandler(impl SRPCActivationServer, serviceID string) srpc.Handler {
	if serviceID == "" {
		serviceID = SRPCActivationServiceID
	}
	return &SRPCActivationHandler{impl: impl, serviceID: serviceID}
}

// SRPCRegisterActivation registers the implementation with the mux.
// Uses the default serviceID: bldr.plugin.Activation
func SRPCRegisterActivation(mux srpc.Mux, impl SRPCActivationServer) error {
	return mux.Register(NewSRPCActivationHandler(impl, ""))
}

func (d *SRPCActivationHandler) GetServiceID() string { return d.serviceID }

func (SRPCActivationHandler) GetMethodIDs() []string {
	return []string{
		"Check",
		"Activate",
	}
}

func (d *SRPCActivationHandler) InvokeMethod(
	serviceID, methodID string,
	strm srpc.Stream,
) (bool, error) {
	if serviceID != "" && serviceID != d.GetServiceID() {
		return false, nil
	}

	switch methodID {
	case "Check":
		return true, d.InvokeMethod_Check(d.impl, strm)
	case "Activate":
		return true, d.InvokeMethod_Activate(d.impl, strm)
	default:
		return false, nil
	}
}

func (SRPCActivationHandler) InvokeMethod_Check(impl SRPCActivationServer, strm srpc.Stream) error {
	req := new(CheckActivationRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	out, err := impl.Check(strm.Context(), req)
	if err != nil {
		return err
	}
	return strm.MsgSend(out)
}

func (SRPCActivationHandler) InvokeMethod_Activate(impl SRPCActivationServer, strm srpc.Stream) error {
	req := new(ActivatePluginRequest)
	if err := strm.MsgRecv(req); err != nil {
		return err
	}
	out, err := impl.Activate(strm.Context(), req)
	if err != nil {
		return err
	}
	return strm.MsgSend(out)
}

type SRPCActivation_CheckStream interface {
	srpc.Stream
}

type srpcActivation_CheckStream struct {
	srpc.Stream
}

type SRPCActivation_ActivateStream interface {
	srpc.Stream
}

type srpcActivation_ActivateStream struct {
	srpc.Stream
}