vpp-maglev/internal/grpcapi/maglev_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v3.21.12
// source: proto/maglev.proto

package grpcapi

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

const (
	Maglev_ListFrontends_FullMethodName                = "/maglev.Maglev/ListFrontends"
	Maglev_GetFrontend_FullMethodName                  = "/maglev.Maglev/GetFrontend"
	Maglev_ListBackends_FullMethodName                 = "/maglev.Maglev/ListBackends"
	Maglev_GetBackend_FullMethodName                   = "/maglev.Maglev/GetBackend"
	Maglev_PauseBackend_FullMethodName                 = "/maglev.Maglev/PauseBackend"
	Maglev_ResumeBackend_FullMethodName                = "/maglev.Maglev/ResumeBackend"
	Maglev_EnableBackend_FullMethodName                = "/maglev.Maglev/EnableBackend"
	Maglev_DisableBackend_FullMethodName               = "/maglev.Maglev/DisableBackend"
	Maglev_ListHealthChecks_FullMethodName             = "/maglev.Maglev/ListHealthChecks"
	Maglev_GetHealthCheck_FullMethodName               = "/maglev.Maglev/GetHealthCheck"
	Maglev_SetFrontendPoolBackendWeight_FullMethodName = "/maglev.Maglev/SetFrontendPoolBackendWeight"
	Maglev_WatchEvents_FullMethodName                  = "/maglev.Maglev/WatchEvents"
	Maglev_CheckConfig_FullMethodName                  = "/maglev.Maglev/CheckConfig"
	Maglev_ReloadConfig_FullMethodName                 = "/maglev.Maglev/ReloadConfig"
)

// MaglevClient is the client API for Maglev 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.
//
// Maglev exposes the state of backend health for all frontends.
type MaglevClient interface {
	ListFrontends(ctx context.Context, in *ListFrontendsRequest, opts ...grpc.CallOption) (*ListFrontendsResponse, error)
	GetFrontend(ctx context.Context, in *GetFrontendRequest, opts ...grpc.CallOption) (*FrontendInfo, error)
	ListBackends(ctx context.Context, in *ListBackendsRequest, opts ...grpc.CallOption) (*ListBackendsResponse, error)
	GetBackend(ctx context.Context, in *GetBackendRequest, opts ...grpc.CallOption) (*BackendInfo, error)
	PauseBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error)
	ResumeBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error)
	EnableBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error)
	DisableBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error)
	ListHealthChecks(ctx context.Context, in *ListHealthChecksRequest, opts ...grpc.CallOption) (*ListHealthChecksResponse, error)
	GetHealthCheck(ctx context.Context, in *GetHealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckInfo, error)
	SetFrontendPoolBackendWeight(ctx context.Context, in *SetWeightRequest, opts ...grpc.CallOption) (*FrontendInfo, error)
	WatchEvents(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Event], error)
	CheckConfig(ctx context.Context, in *CheckConfigRequest, opts ...grpc.CallOption) (*CheckConfigResponse, error)
	ReloadConfig(ctx context.Context, in *ReloadConfigRequest, opts ...grpc.CallOption) (*ReloadConfigResponse, error)
}

type maglevClient struct {
	cc grpc.ClientConnInterface
}

func NewMaglevClient(cc grpc.ClientConnInterface) MaglevClient {
	return &maglevClient{cc}
}

func (c *maglevClient) ListFrontends(ctx context.Context, in *ListFrontendsRequest, opts ...grpc.CallOption) (*ListFrontendsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListFrontendsResponse)
	err := c.cc.Invoke(ctx, Maglev_ListFrontends_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) GetFrontend(ctx context.Context, in *GetFrontendRequest, opts ...grpc.CallOption) (*FrontendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FrontendInfo)
	err := c.cc.Invoke(ctx, Maglev_GetFrontend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) ListBackends(ctx context.Context, in *ListBackendsRequest, opts ...grpc.CallOption) (*ListBackendsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListBackendsResponse)
	err := c.cc.Invoke(ctx, Maglev_ListBackends_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) GetBackend(ctx context.Context, in *GetBackendRequest, opts ...grpc.CallOption) (*BackendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BackendInfo)
	err := c.cc.Invoke(ctx, Maglev_GetBackend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) PauseBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BackendInfo)
	err := c.cc.Invoke(ctx, Maglev_PauseBackend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) ResumeBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BackendInfo)
	err := c.cc.Invoke(ctx, Maglev_ResumeBackend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) EnableBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BackendInfo)
	err := c.cc.Invoke(ctx, Maglev_EnableBackend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) DisableBackend(ctx context.Context, in *BackendRequest, opts ...grpc.CallOption) (*BackendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BackendInfo)
	err := c.cc.Invoke(ctx, Maglev_DisableBackend_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) ListHealthChecks(ctx context.Context, in *ListHealthChecksRequest, opts ...grpc.CallOption) (*ListHealthChecksResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListHealthChecksResponse)
	err := c.cc.Invoke(ctx, Maglev_ListHealthChecks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) GetHealthCheck(ctx context.Context, in *GetHealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(HealthCheckInfo)
	err := c.cc.Invoke(ctx, Maglev_GetHealthCheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) SetFrontendPoolBackendWeight(ctx context.Context, in *SetWeightRequest, opts ...grpc.CallOption) (*FrontendInfo, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FrontendInfo)
	err := c.cc.Invoke(ctx, Maglev_SetFrontendPoolBackendWeight_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) WatchEvents(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Event], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Maglev_ServiceDesc.Streams[0], Maglev_WatchEvents_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[WatchRequest, Event]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

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

func (c *maglevClient) CheckConfig(ctx context.Context, in *CheckConfigRequest, opts ...grpc.CallOption) (*CheckConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CheckConfigResponse)
	err := c.cc.Invoke(ctx, Maglev_CheckConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *maglevClient) ReloadConfig(ctx context.Context, in *ReloadConfigRequest, opts ...grpc.CallOption) (*ReloadConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReloadConfigResponse)
	err := c.cc.Invoke(ctx, Maglev_ReloadConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MaglevServer is the server API for Maglev service.
// All implementations must embed UnimplementedMaglevServer
// for forward compatibility.
//
// Maglev exposes the state of backend health for all frontends.
type MaglevServer interface {
	ListFrontends(context.Context, *ListFrontendsRequest) (*ListFrontendsResponse, error)
	GetFrontend(context.Context, *GetFrontendRequest) (*FrontendInfo, error)
	ListBackends(context.Context, *ListBackendsRequest) (*ListBackendsResponse, error)
	GetBackend(context.Context, *GetBackendRequest) (*BackendInfo, error)
	PauseBackend(context.Context, *BackendRequest) (*BackendInfo, error)
	ResumeBackend(context.Context, *BackendRequest) (*BackendInfo, error)
	EnableBackend(context.Context, *BackendRequest) (*BackendInfo, error)
	DisableBackend(context.Context, *BackendRequest) (*BackendInfo, error)
	ListHealthChecks(context.Context, *ListHealthChecksRequest) (*ListHealthChecksResponse, error)
	GetHealthCheck(context.Context, *GetHealthCheckRequest) (*HealthCheckInfo, error)
	SetFrontendPoolBackendWeight(context.Context, *SetWeightRequest) (*FrontendInfo, error)
	WatchEvents(*WatchRequest, grpc.ServerStreamingServer[Event]) error
	CheckConfig(context.Context, *CheckConfigRequest) (*CheckConfigResponse, error)
	ReloadConfig(context.Context, *ReloadConfigRequest) (*ReloadConfigResponse, error)
	mustEmbedUnimplementedMaglevServer()
}

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

func (UnimplementedMaglevServer) ListFrontends(context.Context, *ListFrontendsRequest) (*ListFrontendsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListFrontends not implemented")
}
func (UnimplementedMaglevServer) GetFrontend(context.Context, *GetFrontendRequest) (*FrontendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetFrontend not implemented")
}
func (UnimplementedMaglevServer) ListBackends(context.Context, *ListBackendsRequest) (*ListBackendsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListBackends not implemented")
}
func (UnimplementedMaglevServer) GetBackend(context.Context, *GetBackendRequest) (*BackendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetBackend not implemented")
}
func (UnimplementedMaglevServer) PauseBackend(context.Context, *BackendRequest) (*BackendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method PauseBackend not implemented")
}
func (UnimplementedMaglevServer) ResumeBackend(context.Context, *BackendRequest) (*BackendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method ResumeBackend not implemented")
}
func (UnimplementedMaglevServer) EnableBackend(context.Context, *BackendRequest) (*BackendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method EnableBackend not implemented")
}
func (UnimplementedMaglevServer) DisableBackend(context.Context, *BackendRequest) (*BackendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method DisableBackend not implemented")
}
func (UnimplementedMaglevServer) ListHealthChecks(context.Context, *ListHealthChecksRequest) (*ListHealthChecksResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListHealthChecks not implemented")
}
func (UnimplementedMaglevServer) GetHealthCheck(context.Context, *GetHealthCheckRequest) (*HealthCheckInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method GetHealthCheck not implemented")
}
func (UnimplementedMaglevServer) SetFrontendPoolBackendWeight(context.Context, *SetWeightRequest) (*FrontendInfo, error) {
	return nil, status.Error(codes.Unimplemented, "method SetFrontendPoolBackendWeight not implemented")
}
func (UnimplementedMaglevServer) WatchEvents(*WatchRequest, grpc.ServerStreamingServer[Event]) error {
	return status.Error(codes.Unimplemented, "method WatchEvents not implemented")
}
func (UnimplementedMaglevServer) CheckConfig(context.Context, *CheckConfigRequest) (*CheckConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CheckConfig not implemented")
}
func (UnimplementedMaglevServer) ReloadConfig(context.Context, *ReloadConfigRequest) (*ReloadConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ReloadConfig not implemented")
}
func (UnimplementedMaglevServer) mustEmbedUnimplementedMaglevServer() {}
func (UnimplementedMaglevServer) testEmbeddedByValue()                {}

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

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

func _Maglev_ListFrontends_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFrontendsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).ListFrontends(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_ListFrontends_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).ListFrontends(ctx, req.(*ListFrontendsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_GetFrontend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFrontendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).GetFrontend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_GetFrontend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).GetFrontend(ctx, req.(*GetFrontendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_ListBackends_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListBackendsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).ListBackends(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_ListBackends_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).ListBackends(ctx, req.(*ListBackendsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_GetBackend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBackendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).GetBackend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_GetBackend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).GetBackend(ctx, req.(*GetBackendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_PauseBackend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).PauseBackend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_PauseBackend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).PauseBackend(ctx, req.(*BackendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_ResumeBackend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).ResumeBackend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_ResumeBackend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).ResumeBackend(ctx, req.(*BackendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_EnableBackend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).EnableBackend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_EnableBackend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).EnableBackend(ctx, req.(*BackendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_DisableBackend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackendRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).DisableBackend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_DisableBackend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).DisableBackend(ctx, req.(*BackendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_ListHealthChecks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListHealthChecksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).ListHealthChecks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_ListHealthChecks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).ListHealthChecks(ctx, req.(*ListHealthChecksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_GetHealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetHealthCheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).GetHealthCheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_GetHealthCheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).GetHealthCheck(ctx, req.(*GetHealthCheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_SetFrontendPoolBackendWeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetWeightRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).SetFrontendPoolBackendWeight(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_SetFrontendPoolBackendWeight_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).SetFrontendPoolBackendWeight(ctx, req.(*SetWeightRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_WatchEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MaglevServer).WatchEvents(m, &grpc.GenericServerStream[WatchRequest, Event]{ServerStream: stream})
}

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

func _Maglev_CheckConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).CheckConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_CheckConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).CheckConfig(ctx, req.(*CheckConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Maglev_ReloadConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReloadConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MaglevServer).ReloadConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Maglev_ReloadConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MaglevServer).ReloadConfig(ctx, req.(*ReloadConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Maglev_ServiceDesc is the grpc.ServiceDesc for Maglev service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Maglev_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "maglev.Maglev",
	HandlerType: (*MaglevServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListFrontends",
			Handler:    _Maglev_ListFrontends_Handler,
		},
		{
			MethodName: "GetFrontend",
			Handler:    _Maglev_GetFrontend_Handler,
		},
		{
			MethodName: "ListBackends",
			Handler:    _Maglev_ListBackends_Handler,
		},
		{
			MethodName: "GetBackend",
			Handler:    _Maglev_GetBackend_Handler,
		},
		{
			MethodName: "PauseBackend",
			Handler:    _Maglev_PauseBackend_Handler,
		},
		{
			MethodName: "ResumeBackend",
			Handler:    _Maglev_ResumeBackend_Handler,
		},
		{
			MethodName: "EnableBackend",
			Handler:    _Maglev_EnableBackend_Handler,
		},
		{
			MethodName: "DisableBackend",
			Handler:    _Maglev_DisableBackend_Handler,
		},
		{
			MethodName: "ListHealthChecks",
			Handler:    _Maglev_ListHealthChecks_Handler,
		},
		{
			MethodName: "GetHealthCheck",
			Handler:    _Maglev_GetHealthCheck_Handler,
		},
		{
			MethodName: "SetFrontendPoolBackendWeight",
			Handler:    _Maglev_SetFrontendPoolBackendWeight_Handler,
		},
		{
			MethodName: "CheckConfig",
			Handler:    _Maglev_CheckConfig_Handler,
		},
		{
			MethodName: "ReloadConfig",
			Handler:    _Maglev_ReloadConfig_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchEvents",
			Handler:       _Maglev_WatchEvents_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "proto/maglev.proto",
}