services.gen_grpc.pb.go

// Copyright (c) 2023 Arista Networks, Inc.  All rights reserved.
// Use of this source code is governed by the Apache License 2.0
// that can be found in the COPYING file.

//
// Code generated by boomtown. DO NOT EDIT.
//

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.24.4
// source: arista/alert.v1/services.gen.proto

package alert

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	AlertService_GetOne_FullMethodName        = "/arista.alert.v1.AlertService/GetOne"
	AlertService_GetAll_FullMethodName        = "/arista.alert.v1.AlertService/GetAll"
	AlertService_Subscribe_FullMethodName     = "/arista.alert.v1.AlertService/Subscribe"
	AlertService_SubscribeMeta_FullMethodName = "/arista.alert.v1.AlertService/SubscribeMeta"
)

// AlertServiceClient is the client API for AlertService 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 AlertServiceClient interface {
	GetOne(ctx context.Context, in *AlertRequest, opts ...grpc.CallOption) (*AlertResponse, error)
	GetAll(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_SubscribeClient, error)
	SubscribeMeta(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_SubscribeMetaClient, error)
}

type alertServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAlertServiceClient(cc grpc.ClientConnInterface) AlertServiceClient {
	return &alertServiceClient{cc}
}

func (c *alertServiceClient) GetOne(ctx context.Context, in *AlertRequest, opts ...grpc.CallOption) (*AlertResponse, error) {
	out := new(AlertResponse)
	err := c.cc.Invoke(ctx, AlertService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *alertServiceClient) GetAll(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertService_ServiceDesc.Streams[0], AlertService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertServiceGetAllClient{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
}

type AlertService_GetAllClient interface {
	Recv() (*AlertStreamResponse, error)
	grpc.ClientStream
}

type alertServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *alertServiceClient) Subscribe(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertService_ServiceDesc.Streams[1], AlertService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertServiceSubscribeClient{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
}

type AlertService_SubscribeClient interface {
	Recv() (*AlertStreamResponse, error)
	grpc.ClientStream
}

type alertServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *alertServiceClient) SubscribeMeta(ctx context.Context, in *AlertStreamRequest, opts ...grpc.CallOption) (AlertService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertService_ServiceDesc.Streams[2], AlertService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertServiceSubscribeMetaClient{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
}

type AlertService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type alertServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// AlertServiceServer is the server API for AlertService service.
// All implementations must embed UnimplementedAlertServiceServer
// for forward compatibility
type AlertServiceServer interface {
	GetOne(context.Context, *AlertRequest) (*AlertResponse, error)
	GetAll(*AlertStreamRequest, AlertService_GetAllServer) error
	Subscribe(*AlertStreamRequest, AlertService_SubscribeServer) error
	SubscribeMeta(*AlertStreamRequest, AlertService_SubscribeMetaServer) error
	mustEmbedUnimplementedAlertServiceServer()
}

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

func (UnimplementedAlertServiceServer) GetOne(context.Context, *AlertRequest) (*AlertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAlertServiceServer) GetAll(*AlertStreamRequest, AlertService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAlertServiceServer) Subscribe(*AlertStreamRequest, AlertService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAlertServiceServer) SubscribeMeta(*AlertStreamRequest, AlertService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAlertServiceServer) mustEmbedUnimplementedAlertServiceServer() {}

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

func RegisterAlertServiceServer(s grpc.ServiceRegistrar, srv AlertServiceServer) {
	s.RegisterService(&AlertService_ServiceDesc, srv)
}

func _AlertService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AlertRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AlertServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AlertService_GetOne_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AlertServiceServer).GetOne(ctx, req.(*AlertRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AlertService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertServiceServer).GetAll(m, &alertServiceGetAllServer{stream})
}

type AlertService_GetAllServer interface {
	Send(*AlertStreamResponse) error
	grpc.ServerStream
}

type alertServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *alertServiceGetAllServer) Send(m *AlertStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AlertService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertServiceServer).Subscribe(m, &alertServiceSubscribeServer{stream})
}

type AlertService_SubscribeServer interface {
	Send(*AlertStreamResponse) error
	grpc.ServerStream
}

type alertServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *alertServiceSubscribeServer) Send(m *AlertStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AlertService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertServiceServer).SubscribeMeta(m, &alertServiceSubscribeMetaServer{stream})
}

type AlertService_SubscribeMetaServer interface {
	Send(*MetaResponse) error
	grpc.ServerStream
}

type alertServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

func (x *alertServiceSubscribeMetaServer) Send(m *MetaResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AlertService_ServiceDesc is the grpc.ServiceDesc for AlertService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AlertService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.alert.v1.AlertService",
	HandlerType: (*AlertServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AlertService_GetOne_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _AlertService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AlertService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AlertService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/alert.v1/services.gen.proto",
}

const (
	AlertConfigService_GetOne_FullMethodName        = "/arista.alert.v1.AlertConfigService/GetOne"
	AlertConfigService_GetAll_FullMethodName        = "/arista.alert.v1.AlertConfigService/GetAll"
	AlertConfigService_Subscribe_FullMethodName     = "/arista.alert.v1.AlertConfigService/Subscribe"
	AlertConfigService_SubscribeMeta_FullMethodName = "/arista.alert.v1.AlertConfigService/SubscribeMeta"
	AlertConfigService_Set_FullMethodName           = "/arista.alert.v1.AlertConfigService/Set"
)

// AlertConfigServiceClient is the client API for AlertConfigService 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 AlertConfigServiceClient interface {
	GetOne(ctx context.Context, in *AlertConfigRequest, opts ...grpc.CallOption) (*AlertConfigResponse, error)
	GetAll(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_SubscribeClient, error)
	SubscribeMeta(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *AlertConfigSetRequest, opts ...grpc.CallOption) (*AlertConfigSetResponse, error)
}

type alertConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAlertConfigServiceClient(cc grpc.ClientConnInterface) AlertConfigServiceClient {
	return &alertConfigServiceClient{cc}
}

func (c *alertConfigServiceClient) GetOne(ctx context.Context, in *AlertConfigRequest, opts ...grpc.CallOption) (*AlertConfigResponse, error) {
	out := new(AlertConfigResponse)
	err := c.cc.Invoke(ctx, AlertConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *alertConfigServiceClient) GetAll(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertConfigService_ServiceDesc.Streams[0], AlertConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertConfigServiceGetAllClient{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
}

type AlertConfigService_GetAllClient interface {
	Recv() (*AlertConfigStreamResponse, error)
	grpc.ClientStream
}

type alertConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *alertConfigServiceClient) Subscribe(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertConfigService_ServiceDesc.Streams[1], AlertConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertConfigServiceSubscribeClient{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
}

type AlertConfigService_SubscribeClient interface {
	Recv() (*AlertConfigStreamResponse, error)
	grpc.ClientStream
}

type alertConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *alertConfigServiceClient) SubscribeMeta(ctx context.Context, in *AlertConfigStreamRequest, opts ...grpc.CallOption) (AlertConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AlertConfigService_ServiceDesc.Streams[2], AlertConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &alertConfigServiceSubscribeMetaClient{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
}

type AlertConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type alertConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *alertConfigServiceClient) Set(ctx context.Context, in *AlertConfigSetRequest, opts ...grpc.CallOption) (*AlertConfigSetResponse, error) {
	out := new(AlertConfigSetResponse)
	err := c.cc.Invoke(ctx, AlertConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AlertConfigServiceServer is the server API for AlertConfigService service.
// All implementations must embed UnimplementedAlertConfigServiceServer
// for forward compatibility
type AlertConfigServiceServer interface {
	GetOne(context.Context, *AlertConfigRequest) (*AlertConfigResponse, error)
	GetAll(*AlertConfigStreamRequest, AlertConfigService_GetAllServer) error
	Subscribe(*AlertConfigStreamRequest, AlertConfigService_SubscribeServer) error
	SubscribeMeta(*AlertConfigStreamRequest, AlertConfigService_SubscribeMetaServer) error
	Set(context.Context, *AlertConfigSetRequest) (*AlertConfigSetResponse, error)
	mustEmbedUnimplementedAlertConfigServiceServer()
}

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

func (UnimplementedAlertConfigServiceServer) GetOne(context.Context, *AlertConfigRequest) (*AlertConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAlertConfigServiceServer) GetAll(*AlertConfigStreamRequest, AlertConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAlertConfigServiceServer) Subscribe(*AlertConfigStreamRequest, AlertConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAlertConfigServiceServer) SubscribeMeta(*AlertConfigStreamRequest, AlertConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAlertConfigServiceServer) Set(context.Context, *AlertConfigSetRequest) (*AlertConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedAlertConfigServiceServer) mustEmbedUnimplementedAlertConfigServiceServer() {}

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

func RegisterAlertConfigServiceServer(s grpc.ServiceRegistrar, srv AlertConfigServiceServer) {
	s.RegisterService(&AlertConfigService_ServiceDesc, srv)
}

func _AlertConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AlertConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AlertConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AlertConfigService_GetOne_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AlertConfigServiceServer).GetOne(ctx, req.(*AlertConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AlertConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertConfigServiceServer).GetAll(m, &alertConfigServiceGetAllServer{stream})
}

type AlertConfigService_GetAllServer interface {
	Send(*AlertConfigStreamResponse) error
	grpc.ServerStream
}

type alertConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *alertConfigServiceGetAllServer) Send(m *AlertConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AlertConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertConfigServiceServer).Subscribe(m, &alertConfigServiceSubscribeServer{stream})
}

type AlertConfigService_SubscribeServer interface {
	Send(*AlertConfigStreamResponse) error
	grpc.ServerStream
}

type alertConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *alertConfigServiceSubscribeServer) Send(m *AlertConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AlertConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AlertConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AlertConfigServiceServer).SubscribeMeta(m, &alertConfigServiceSubscribeMetaServer{stream})
}

type AlertConfigService_SubscribeMetaServer interface {
	Send(*MetaResponse) error
	grpc.ServerStream
}

type alertConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

func (x *alertConfigServiceSubscribeMetaServer) Send(m *MetaResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AlertConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AlertConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AlertConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AlertConfigService_Set_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AlertConfigServiceServer).Set(ctx, req.(*AlertConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AlertConfigService_ServiceDesc is the grpc.ServiceDesc for AlertConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AlertConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.alert.v1.AlertConfigService",
	HandlerType: (*AlertConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AlertConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _AlertConfigService_Set_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _AlertConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AlertConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AlertConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/alert.v1/services.gen.proto",
}

const (
	DefaultTemplateService_GetOne_FullMethodName        = "/arista.alert.v1.DefaultTemplateService/GetOne"
	DefaultTemplateService_GetSome_FullMethodName       = "/arista.alert.v1.DefaultTemplateService/GetSome"
	DefaultTemplateService_GetAll_FullMethodName        = "/arista.alert.v1.DefaultTemplateService/GetAll"
	DefaultTemplateService_Subscribe_FullMethodName     = "/arista.alert.v1.DefaultTemplateService/Subscribe"
	DefaultTemplateService_GetMeta_FullMethodName       = "/arista.alert.v1.DefaultTemplateService/GetMeta"
	DefaultTemplateService_SubscribeMeta_FullMethodName = "/arista.alert.v1.DefaultTemplateService/SubscribeMeta"
)

// DefaultTemplateServiceClient is the client API for DefaultTemplateService 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 DefaultTemplateServiceClient interface {
	GetOne(ctx context.Context, in *DefaultTemplateRequest, opts ...grpc.CallOption) (*DefaultTemplateResponse, error)
	GetSome(ctx context.Context, in *DefaultTemplateSomeRequest, opts ...grpc.CallOption) (DefaultTemplateService_GetSomeClient, error)
	GetAll(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_GetAllClient, error)
	Subscribe(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_SubscribeMetaClient, error)
}

type defaultTemplateServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDefaultTemplateServiceClient(cc grpc.ClientConnInterface) DefaultTemplateServiceClient {
	return &defaultTemplateServiceClient{cc}
}

func (c *defaultTemplateServiceClient) GetOne(ctx context.Context, in *DefaultTemplateRequest, opts ...grpc.CallOption) (*DefaultTemplateResponse, error) {
	out := new(DefaultTemplateResponse)
	err := c.cc.Invoke(ctx, DefaultTemplateService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *defaultTemplateServiceClient) GetSome(ctx context.Context, in *DefaultTemplateSomeRequest, opts ...grpc.CallOption) (DefaultTemplateService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DefaultTemplateService_ServiceDesc.Streams[0], DefaultTemplateService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &defaultTemplateServiceGetSomeClient{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
}

type DefaultTemplateService_GetSomeClient interface {
	Recv() (*DefaultTemplateSomeResponse, error)
	grpc.ClientStream
}

type defaultTemplateServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *defaultTemplateServiceClient) GetAll(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &DefaultTemplateService_ServiceDesc.Streams[1], DefaultTemplateService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &defaultTemplateServiceGetAllClient{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
}

type DefaultTemplateService_GetAllClient interface {
	Recv() (*DefaultTemplateStreamResponse, error)
	grpc.ClientStream
}

type defaultTemplateServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *defaultTemplateServiceClient) Subscribe(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DefaultTemplateService_ServiceDesc.Streams[2], DefaultTemplateService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &defaultTemplateServiceSubscribeClient{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
}

type DefaultTemplateService_SubscribeClient interface {
	Recv() (*DefaultTemplateStreamResponse, error)
	grpc.ClientStream
}

type defaultTemplateServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *defaultTemplateServiceClient) GetMeta(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, DefaultTemplateService_GetMeta_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *defaultTemplateServiceClient) SubscribeMeta(ctx context.Context, in *DefaultTemplateStreamRequest, opts ...grpc.CallOption) (DefaultTemplateService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &DefaultTemplateService_ServiceDesc.Streams[3], DefaultTemplateService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &defaultTemplateServiceSubscribeMetaClient{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
}

type DefaultTemplateService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type defaultTemplateServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// DefaultTemplateServiceServer is the server API for DefaultTemplateService service.
// All implementations must embed UnimplementedDefaultTemplateServiceServer
// for forward compatibility
type DefaultTemplateServiceServer interface {
	GetOne(context.Context, *DefaultTemplateRequest) (*DefaultTemplateResponse, error)
	GetSome(*DefaultTemplateSomeRequest, DefaultTemplateService_GetSomeServer) error
	GetAll(*DefaultTemplateStreamRequest, DefaultTemplateService_GetAllServer) error
	Subscribe(*DefaultTemplateStreamRequest, DefaultTemplateService_SubscribeServer) error
	GetMeta(context.Context, *DefaultTemplateStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*DefaultTemplateStreamRequest, DefaultTemplateService_SubscribeMetaServer) error
	mustEmbedUnimplementedDefaultTemplateServiceServer()
}

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

func (UnimplementedDefaultTemplateServiceServer) GetOne(context.Context, *DefaultTemplateRequest) (*DefaultTemplateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) GetSome(*DefaultTemplateSomeRequest, DefaultTemplateService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) GetAll(*DefaultTemplateStreamRequest, DefaultTemplateService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) Subscribe(*DefaultTemplateStreamRequest, DefaultTemplateService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) GetMeta(context.Context, *DefaultTemplateStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) SubscribeMeta(*DefaultTemplateStreamRequest, DefaultTemplateService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedDefaultTemplateServiceServer) mustEmbedUnimplementedDefaultTemplateServiceServer() {
}

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

func RegisterDefaultTemplateServiceServer(s grpc.ServiceRegistrar, srv DefaultTemplateServiceServer) {
	s.RegisterService(&DefaultTemplateService_ServiceDesc, srv)
}

func _DefaultTemplateService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefaultTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DefaultTemplateServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DefaultTemplateService_GetOne_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DefaultTemplateServiceServer).GetOne(ctx, req.(*DefaultTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DefaultTemplateService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DefaultTemplateSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DefaultTemplateServiceServer).GetSome(m, &defaultTemplateServiceGetSomeServer{stream})
}

type DefaultTemplateService_GetSomeServer interface {
	Send(*DefaultTemplateSomeResponse) error
	grpc.ServerStream
}

type defaultTemplateServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *defaultTemplateServiceGetSomeServer) Send(m *DefaultTemplateSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DefaultTemplateService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DefaultTemplateStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DefaultTemplateServiceServer).GetAll(m, &defaultTemplateServiceGetAllServer{stream})
}

type DefaultTemplateService_GetAllServer interface {
	Send(*DefaultTemplateStreamResponse) error
	grpc.ServerStream
}

type defaultTemplateServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *defaultTemplateServiceGetAllServer) Send(m *DefaultTemplateStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DefaultTemplateService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DefaultTemplateStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DefaultTemplateServiceServer).Subscribe(m, &defaultTemplateServiceSubscribeServer{stream})
}

type DefaultTemplateService_SubscribeServer interface {
	Send(*DefaultTemplateStreamResponse) error
	grpc.ServerStream
}

type defaultTemplateServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *defaultTemplateServiceSubscribeServer) Send(m *DefaultTemplateStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DefaultTemplateService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefaultTemplateStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DefaultTemplateServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DefaultTemplateService_GetMeta_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DefaultTemplateServiceServer).GetMeta(ctx, req.(*DefaultTemplateStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DefaultTemplateService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DefaultTemplateStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DefaultTemplateServiceServer).SubscribeMeta(m, &defaultTemplateServiceSubscribeMetaServer{stream})
}

type DefaultTemplateService_SubscribeMetaServer interface {
	Send(*MetaResponse) error
	grpc.ServerStream
}

type defaultTemplateServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

func (x *defaultTemplateServiceSubscribeMetaServer) Send(m *MetaResponse) error {
	return x.ServerStream.SendMsg(m)
}

// DefaultTemplateService_ServiceDesc is the grpc.ServiceDesc for DefaultTemplateService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DefaultTemplateService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.alert.v1.DefaultTemplateService",
	HandlerType: (*DefaultTemplateServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _DefaultTemplateService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _DefaultTemplateService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _DefaultTemplateService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _DefaultTemplateService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _DefaultTemplateService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _DefaultTemplateService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/alert.v1/services.gen.proto",
}

const (
	TemplateConfigService_GetOne_FullMethodName        = "/arista.alert.v1.TemplateConfigService/GetOne"
	TemplateConfigService_GetSome_FullMethodName       = "/arista.alert.v1.TemplateConfigService/GetSome"
	TemplateConfigService_GetAll_FullMethodName        = "/arista.alert.v1.TemplateConfigService/GetAll"
	TemplateConfigService_Subscribe_FullMethodName     = "/arista.alert.v1.TemplateConfigService/Subscribe"
	TemplateConfigService_GetMeta_FullMethodName       = "/arista.alert.v1.TemplateConfigService/GetMeta"
	TemplateConfigService_SubscribeMeta_FullMethodName = "/arista.alert.v1.TemplateConfigService/SubscribeMeta"
	TemplateConfigService_Set_FullMethodName           = "/arista.alert.v1.TemplateConfigService/Set"
	TemplateConfigService_SetSome_FullMethodName       = "/arista.alert.v1.TemplateConfigService/SetSome"
	TemplateConfigService_Delete_FullMethodName        = "/arista.alert.v1.TemplateConfigService/Delete"
	TemplateConfigService_DeleteSome_FullMethodName    = "/arista.alert.v1.TemplateConfigService/DeleteSome"
	TemplateConfigService_DeleteAll_FullMethodName     = "/arista.alert.v1.TemplateConfigService/DeleteAll"
)

// TemplateConfigServiceClient is the client API for TemplateConfigService 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 TemplateConfigServiceClient interface {
	GetOne(ctx context.Context, in *TemplateConfigRequest, opts ...grpc.CallOption) (*TemplateConfigResponse, error)
	GetSome(ctx context.Context, in *TemplateConfigSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *TemplateConfigSetRequest, opts ...grpc.CallOption) (*TemplateConfigSetResponse, error)
	SetSome(ctx context.Context, in *TemplateConfigSetSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *TemplateConfigDeleteRequest, opts ...grpc.CallOption) (*TemplateConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *TemplateConfigDeleteSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *TemplateConfigDeleteAllRequest, opts ...grpc.CallOption) (TemplateConfigService_DeleteAllClient, error)
}

type templateConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTemplateConfigServiceClient(cc grpc.ClientConnInterface) TemplateConfigServiceClient {
	return &templateConfigServiceClient{cc}
}

func (c *templateConfigServiceClient) GetOne(ctx context.Context, in *TemplateConfigRequest, opts ...grpc.CallOption) (*TemplateConfigResponse, error) {
	out := new(TemplateConfigResponse)
	err := c.cc.Invoke(ctx, TemplateConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *templateConfigServiceClient) GetSome(ctx context.Context, in *TemplateConfigSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[0], TemplateConfigService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceGetSomeClient{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
}

type TemplateConfigService_GetSomeClient interface {
	Recv() (*TemplateConfigSomeResponse, error)
	grpc.ClientStream
}

type templateConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) GetAll(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[1], TemplateConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceGetAllClient{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
}

type TemplateConfigService_GetAllClient interface {
	Recv() (*TemplateConfigStreamResponse, error)
	grpc.ClientStream
}

type templateConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) Subscribe(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[2], TemplateConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceSubscribeClient{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
}

type TemplateConfigService_SubscribeClient interface {
	Recv() (*TemplateConfigStreamResponse, error)
	grpc.ClientStream
}

type templateConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) GetMeta(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, TemplateConfigService_GetMeta_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *templateConfigServiceClient) SubscribeMeta(ctx context.Context, in *TemplateConfigStreamRequest, opts ...grpc.CallOption) (TemplateConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[3], TemplateConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceSubscribeMetaClient{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
}

type TemplateConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type templateConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) Set(ctx context.Context, in *TemplateConfigSetRequest, opts ...grpc.CallOption) (*TemplateConfigSetResponse, error) {
	out := new(TemplateConfigSetResponse)
	err := c.cc.Invoke(ctx, TemplateConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *templateConfigServiceClient) SetSome(ctx context.Context, in *TemplateConfigSetSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[4], TemplateConfigService_SetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceSetSomeClient{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
}

type TemplateConfigService_SetSomeClient interface {
	Recv() (*TemplateConfigSetSomeResponse, error)
	grpc.ClientStream
}

type templateConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) Delete(ctx context.Context, in *TemplateConfigDeleteRequest, opts ...grpc.CallOption) (*TemplateConfigDeleteResponse, error) {
	out := new(TemplateConfigDeleteResponse)
	err := c.cc.Invoke(ctx, TemplateConfigService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *templateConfigServiceClient) DeleteSome(ctx context.Context, in *TemplateConfigDeleteSomeRequest, opts ...grpc.CallOption) (TemplateConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[5], TemplateConfigService_DeleteSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceDeleteSomeClient{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
}

type TemplateConfigService_DeleteSomeClient interface {
	Recv() (*TemplateConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type templateConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *templateConfigServiceClient) DeleteAll(ctx context.Context, in *TemplateConfigDeleteAllRequest, opts ...grpc.CallOption) (TemplateConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &TemplateConfigService_ServiceDesc.Streams[6], TemplateConfigService_DeleteAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &templateConfigServiceDeleteAllClient{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
}

type TemplateConfigService_DeleteAllClient interface {
	Recv() (*TemplateConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type templateConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// TemplateConfigServiceServer is the server API for TemplateConfigService service.
// All implementations must embed UnimplementedTemplateConfigServiceServer
// for forward compatibility
type TemplateConfigServiceServer interface {
	GetOne(context.Context, *TemplateConfigRequest) (*TemplateConfigResponse, error)
	GetSome(*TemplateConfigSomeRequest, TemplateConfigService_GetSomeServer) error
	GetAll(*TemplateConfigStreamRequest, TemplateConfigService_GetAllServer) error
	Subscribe(*TemplateConfigStreamRequest, TemplateConfigService_SubscribeServer) error
	GetMeta(context.Context, *TemplateConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*TemplateConfigStreamRequest, TemplateConfigService_SubscribeMetaServer) error
	Set(context.Context, *TemplateConfigSetRequest) (*TemplateConfigSetResponse, error)
	SetSome(*TemplateConfigSetSomeRequest, TemplateConfigService_SetSomeServer) error
	Delete(context.Context, *TemplateConfigDeleteRequest) (*TemplateConfigDeleteResponse, error)
	DeleteSome(*TemplateConfigDeleteSomeRequest, TemplateConfigService_DeleteSomeServer) error
	DeleteAll(*TemplateConfigDeleteAllRequest, TemplateConfigService_DeleteAllServer) error
	mustEmbedUnimplementedTemplateConfigServiceServer()
}

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

func (UnimplementedTemplateConfigServiceServer) GetOne(context.Context, *TemplateConfigRequest) (*TemplateConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedTemplateConfigServiceServer) GetSome(*TemplateConfigSomeRequest, TemplateConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedTemplateConfigServiceServer) GetAll(*TemplateConfigStreamRequest, TemplateConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedTemplateConfigServiceServer) Subscribe(*TemplateConfigStreamRequest, TemplateConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedTemplateConfigServiceServer) GetMeta(context.Context, *TemplateConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedTemplateConfigServiceServer) SubscribeMeta(*TemplateConfigStreamRequest, TemplateConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedTemplateConfigServiceServer) Set(context.Context, *TemplateConfigSetRequest) (*TemplateConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedTemplateConfigServiceServer) SetSome(*TemplateConfigSetSomeRequest, TemplateConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedTemplateConfigServiceServer) Delete(context.Context, *TemplateConfigDeleteRequest) (*TemplateConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedTemplateConfigServiceServer) DeleteSome(*TemplateConfigDeleteSomeRequest, TemplateConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedTemplateConfigServiceServer) DeleteAll(*TemplateConfigDeleteAllRequest, TemplateConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedTemplateConfigServiceServer) mustEmbedUnimplementedTemplateConfigServiceServer() {}

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

func RegisterTemplateConfigServiceServer(s grpc.ServiceRegistrar, srv TemplateConfigServiceServer) {
	s.RegisterService(&TemplateConfigService_ServiceDesc, srv)
}

func _TemplateConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TemplateConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TemplateConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TemplateConfigService_GetOne_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TemplateConfigServiceServer).GetOne(ctx, req.(*TemplateConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TemplateConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).GetSome(m, &templateConfigServiceGetSomeServer{stream})
}

type TemplateConfigService_GetSomeServer interface {
	Send(*TemplateConfigSomeResponse) error
	grpc.ServerStream
}

type templateConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceGetSomeServer) Send(m *TemplateConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).GetAll(m, &templateConfigServiceGetAllServer{stream})
}

type TemplateConfigService_GetAllServer interface {
	Send(*TemplateConfigStreamResponse) error
	grpc.ServerStream
}

type templateConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceGetAllServer) Send(m *TemplateConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).Subscribe(m, &templateConfigServiceSubscribeServer{stream})
}

type TemplateConfigService_SubscribeServer interface {
	Send(*TemplateConfigStreamResponse) error
	grpc.ServerStream
}

type templateConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceSubscribeServer) Send(m *TemplateConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TemplateConfigStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TemplateConfigServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TemplateConfigService_GetMeta_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TemplateConfigServiceServer).GetMeta(ctx, req.(*TemplateConfigStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TemplateConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).SubscribeMeta(m, &templateConfigServiceSubscribeMetaServer{stream})
}

type TemplateConfigService_SubscribeMetaServer interface {
	Send(*MetaResponse) error
	grpc.ServerStream
}

type templateConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceSubscribeMetaServer) Send(m *MetaResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TemplateConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TemplateConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TemplateConfigService_Set_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TemplateConfigServiceServer).Set(ctx, req.(*TemplateConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TemplateConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).SetSome(m, &templateConfigServiceSetSomeServer{stream})
}

type TemplateConfigService_SetSomeServer interface {
	Send(*TemplateConfigSetSomeResponse) error
	grpc.ServerStream
}

type templateConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceSetSomeServer) Send(m *TemplateConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TemplateConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TemplateConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TemplateConfigService_Delete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TemplateConfigServiceServer).Delete(ctx, req.(*TemplateConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TemplateConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).DeleteSome(m, &templateConfigServiceDeleteSomeServer{stream})
}

type TemplateConfigService_DeleteSomeServer interface {
	Send(*TemplateConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type templateConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceDeleteSomeServer) Send(m *TemplateConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TemplateConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TemplateConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TemplateConfigServiceServer).DeleteAll(m, &templateConfigServiceDeleteAllServer{stream})
}

type TemplateConfigService_DeleteAllServer interface {
	Send(*TemplateConfigDeleteAllResponse) error
	grpc.ServerStream
}

type templateConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *templateConfigServiceDeleteAllServer) Send(m *TemplateConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// TemplateConfigService_ServiceDesc is the grpc.ServiceDesc for TemplateConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TemplateConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.alert.v1.TemplateConfigService",
	HandlerType: (*TemplateConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _TemplateConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _TemplateConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _TemplateConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _TemplateConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _TemplateConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _TemplateConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _TemplateConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _TemplateConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _TemplateConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _TemplateConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _TemplateConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/alert.v1/services.gen.proto",
}