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/dashboard.v1/services.gen.proto

package dashboard

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 (
	DashboardService_GetOne_FullMethodName        = "/arista.dashboard.v1.DashboardService/GetOne"
	DashboardService_GetSome_FullMethodName       = "/arista.dashboard.v1.DashboardService/GetSome"
	DashboardService_GetAll_FullMethodName        = "/arista.dashboard.v1.DashboardService/GetAll"
	DashboardService_Subscribe_FullMethodName     = "/arista.dashboard.v1.DashboardService/Subscribe"
	DashboardService_GetMeta_FullMethodName       = "/arista.dashboard.v1.DashboardService/GetMeta"
	DashboardService_SubscribeMeta_FullMethodName = "/arista.dashboard.v1.DashboardService/SubscribeMeta"
)

// DashboardServiceClient is the client API for DashboardService 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 DashboardServiceClient interface {
	GetOne(ctx context.Context, in *DashboardRequest, opts ...grpc.CallOption) (*DashboardResponse, error)
	GetSome(ctx context.Context, in *DashboardSomeRequest, opts ...grpc.CallOption) (DashboardService_GetSomeClient, error)
	GetAll(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_GetAllClient, error)
	Subscribe(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_SubscribeMetaClient, error)
}

type dashboardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDashboardServiceClient(cc grpc.ClientConnInterface) DashboardServiceClient {
	return &dashboardServiceClient{cc}
}

func (c *dashboardServiceClient) GetOne(ctx context.Context, in *DashboardRequest, opts ...grpc.CallOption) (*DashboardResponse, error) {
	out := new(DashboardResponse)
	err := c.cc.Invoke(ctx, DashboardService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dashboardServiceClient) GetSome(ctx context.Context, in *DashboardSomeRequest, opts ...grpc.CallOption) (DashboardService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardService_ServiceDesc.Streams[0], DashboardService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardServiceGetSomeClient{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 DashboardService_GetSomeClient interface {
	Recv() (*DashboardSomeResponse, error)
	grpc.ClientStream
}

type dashboardServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *dashboardServiceClient) GetAll(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardService_ServiceDesc.Streams[1], DashboardService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardServiceGetAllClient{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 DashboardService_GetAllClient interface {
	Recv() (*DashboardStreamResponse, error)
	grpc.ClientStream
}

type dashboardServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *dashboardServiceClient) Subscribe(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardService_ServiceDesc.Streams[2], DashboardService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardServiceSubscribeClient{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 DashboardService_SubscribeClient interface {
	Recv() (*DashboardStreamResponse, error)
	grpc.ClientStream
}

type dashboardServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *dashboardServiceClient) SubscribeMeta(ctx context.Context, in *DashboardStreamRequest, opts ...grpc.CallOption) (DashboardService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardService_ServiceDesc.Streams[3], DashboardService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardServiceSubscribeMetaClient{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 DashboardService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type dashboardServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// DashboardServiceServer is the server API for DashboardService service.
// All implementations must embed UnimplementedDashboardServiceServer
// for forward compatibility
type DashboardServiceServer interface {
	GetOne(context.Context, *DashboardRequest) (*DashboardResponse, error)
	GetSome(*DashboardSomeRequest, DashboardService_GetSomeServer) error
	GetAll(*DashboardStreamRequest, DashboardService_GetAllServer) error
	Subscribe(*DashboardStreamRequest, DashboardService_SubscribeServer) error
	GetMeta(context.Context, *DashboardStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*DashboardStreamRequest, DashboardService_SubscribeMetaServer) error
	mustEmbedUnimplementedDashboardServiceServer()
}

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

func (UnimplementedDashboardServiceServer) GetOne(context.Context, *DashboardRequest) (*DashboardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedDashboardServiceServer) GetSome(*DashboardSomeRequest, DashboardService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedDashboardServiceServer) GetAll(*DashboardStreamRequest, DashboardService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedDashboardServiceServer) Subscribe(*DashboardStreamRequest, DashboardService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedDashboardServiceServer) GetMeta(context.Context, *DashboardStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedDashboardServiceServer) SubscribeMeta(*DashboardStreamRequest, DashboardService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedDashboardServiceServer) mustEmbedUnimplementedDashboardServiceServer() {}

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

func RegisterDashboardServiceServer(s grpc.ServiceRegistrar, srv DashboardServiceServer) {
	s.RegisterService(&DashboardService_ServiceDesc, srv)
}

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

func _DashboardService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardServiceServer).GetSome(m, &dashboardServiceGetSomeServer{stream})
}

type DashboardService_GetSomeServer interface {
	Send(*DashboardSomeResponse) error
	grpc.ServerStream
}

type dashboardServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *dashboardServiceGetSomeServer) Send(m *DashboardSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DashboardService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardServiceServer).GetAll(m, &dashboardServiceGetAllServer{stream})
}

type DashboardService_GetAllServer interface {
	Send(*DashboardStreamResponse) error
	grpc.ServerStream
}

type dashboardServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *dashboardServiceGetAllServer) Send(m *DashboardStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DashboardService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardServiceServer).Subscribe(m, &dashboardServiceSubscribeServer{stream})
}

type DashboardService_SubscribeServer interface {
	Send(*DashboardStreamResponse) error
	grpc.ServerStream
}

type dashboardServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *dashboardServiceSubscribeServer) Send(m *DashboardStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _DashboardService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardServiceServer).SubscribeMeta(m, &dashboardServiceSubscribeMetaServer{stream})
}

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

type dashboardServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// DashboardService_ServiceDesc is the grpc.ServiceDesc for DashboardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DashboardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.dashboard.v1.DashboardService",
	HandlerType: (*DashboardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _DashboardService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _DashboardService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _DashboardService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _DashboardService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _DashboardService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _DashboardService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/dashboard.v1/services.gen.proto",
}

const (
	DashboardConfigService_GetOne_FullMethodName        = "/arista.dashboard.v1.DashboardConfigService/GetOne"
	DashboardConfigService_GetSome_FullMethodName       = "/arista.dashboard.v1.DashboardConfigService/GetSome"
	DashboardConfigService_GetAll_FullMethodName        = "/arista.dashboard.v1.DashboardConfigService/GetAll"
	DashboardConfigService_Subscribe_FullMethodName     = "/arista.dashboard.v1.DashboardConfigService/Subscribe"
	DashboardConfigService_GetMeta_FullMethodName       = "/arista.dashboard.v1.DashboardConfigService/GetMeta"
	DashboardConfigService_SubscribeMeta_FullMethodName = "/arista.dashboard.v1.DashboardConfigService/SubscribeMeta"
	DashboardConfigService_Set_FullMethodName           = "/arista.dashboard.v1.DashboardConfigService/Set"
	DashboardConfigService_SetSome_FullMethodName       = "/arista.dashboard.v1.DashboardConfigService/SetSome"
	DashboardConfigService_Delete_FullMethodName        = "/arista.dashboard.v1.DashboardConfigService/Delete"
	DashboardConfigService_DeleteSome_FullMethodName    = "/arista.dashboard.v1.DashboardConfigService/DeleteSome"
	DashboardConfigService_DeleteAll_FullMethodName     = "/arista.dashboard.v1.DashboardConfigService/DeleteAll"
)

// DashboardConfigServiceClient is the client API for DashboardConfigService 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 DashboardConfigServiceClient interface {
	GetOne(ctx context.Context, in *DashboardConfigRequest, opts ...grpc.CallOption) (*DashboardConfigResponse, error)
	GetSome(ctx context.Context, in *DashboardConfigSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *DashboardConfigSetRequest, opts ...grpc.CallOption) (*DashboardConfigSetResponse, error)
	SetSome(ctx context.Context, in *DashboardConfigSetSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *DashboardConfigDeleteRequest, opts ...grpc.CallOption) (*DashboardConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *DashboardConfigDeleteSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *DashboardConfigDeleteAllRequest, opts ...grpc.CallOption) (DashboardConfigService_DeleteAllClient, error)
}

type dashboardConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDashboardConfigServiceClient(cc grpc.ClientConnInterface) DashboardConfigServiceClient {
	return &dashboardConfigServiceClient{cc}
}

func (c *dashboardConfigServiceClient) GetOne(ctx context.Context, in *DashboardConfigRequest, opts ...grpc.CallOption) (*DashboardConfigResponse, error) {
	out := new(DashboardConfigResponse)
	err := c.cc.Invoke(ctx, DashboardConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dashboardConfigServiceClient) GetSome(ctx context.Context, in *DashboardConfigSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[0], DashboardConfigService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceGetSomeClient{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 DashboardConfigService_GetSomeClient interface {
	Recv() (*DashboardConfigSomeResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *dashboardConfigServiceClient) GetAll(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[1], DashboardConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceGetAllClient{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 DashboardConfigService_GetAllClient interface {
	Recv() (*DashboardConfigStreamResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *dashboardConfigServiceClient) Subscribe(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[2], DashboardConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceSubscribeClient{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 DashboardConfigService_SubscribeClient interface {
	Recv() (*DashboardConfigStreamResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *dashboardConfigServiceClient) SubscribeMeta(ctx context.Context, in *DashboardConfigStreamRequest, opts ...grpc.CallOption) (DashboardConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[3], DashboardConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceSubscribeMetaClient{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 DashboardConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *dashboardConfigServiceClient) Set(ctx context.Context, in *DashboardConfigSetRequest, opts ...grpc.CallOption) (*DashboardConfigSetResponse, error) {
	out := new(DashboardConfigSetResponse)
	err := c.cc.Invoke(ctx, DashboardConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dashboardConfigServiceClient) SetSome(ctx context.Context, in *DashboardConfigSetSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[4], DashboardConfigService_SetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceSetSomeClient{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 DashboardConfigService_SetSomeClient interface {
	Recv() (*DashboardConfigSetSomeResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *dashboardConfigServiceClient) Delete(ctx context.Context, in *DashboardConfigDeleteRequest, opts ...grpc.CallOption) (*DashboardConfigDeleteResponse, error) {
	out := new(DashboardConfigDeleteResponse)
	err := c.cc.Invoke(ctx, DashboardConfigService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dashboardConfigServiceClient) DeleteSome(ctx context.Context, in *DashboardConfigDeleteSomeRequest, opts ...grpc.CallOption) (DashboardConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[5], DashboardConfigService_DeleteSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceDeleteSomeClient{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 DashboardConfigService_DeleteSomeClient interface {
	Recv() (*DashboardConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *dashboardConfigServiceClient) DeleteAll(ctx context.Context, in *DashboardConfigDeleteAllRequest, opts ...grpc.CallOption) (DashboardConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &DashboardConfigService_ServiceDesc.Streams[6], DashboardConfigService_DeleteAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardConfigServiceDeleteAllClient{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 DashboardConfigService_DeleteAllClient interface {
	Recv() (*DashboardConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type dashboardConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// DashboardConfigServiceServer is the server API for DashboardConfigService service.
// All implementations must embed UnimplementedDashboardConfigServiceServer
// for forward compatibility
type DashboardConfigServiceServer interface {
	GetOne(context.Context, *DashboardConfigRequest) (*DashboardConfigResponse, error)
	GetSome(*DashboardConfigSomeRequest, DashboardConfigService_GetSomeServer) error
	GetAll(*DashboardConfigStreamRequest, DashboardConfigService_GetAllServer) error
	Subscribe(*DashboardConfigStreamRequest, DashboardConfigService_SubscribeServer) error
	GetMeta(context.Context, *DashboardConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*DashboardConfigStreamRequest, DashboardConfigService_SubscribeMetaServer) error
	Set(context.Context, *DashboardConfigSetRequest) (*DashboardConfigSetResponse, error)
	SetSome(*DashboardConfigSetSomeRequest, DashboardConfigService_SetSomeServer) error
	Delete(context.Context, *DashboardConfigDeleteRequest) (*DashboardConfigDeleteResponse, error)
	DeleteSome(*DashboardConfigDeleteSomeRequest, DashboardConfigService_DeleteSomeServer) error
	DeleteAll(*DashboardConfigDeleteAllRequest, DashboardConfigService_DeleteAllServer) error
	mustEmbedUnimplementedDashboardConfigServiceServer()
}

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

func (UnimplementedDashboardConfigServiceServer) GetOne(context.Context, *DashboardConfigRequest) (*DashboardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedDashboardConfigServiceServer) GetSome(*DashboardConfigSomeRequest, DashboardConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedDashboardConfigServiceServer) GetAll(*DashboardConfigStreamRequest, DashboardConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedDashboardConfigServiceServer) Subscribe(*DashboardConfigStreamRequest, DashboardConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedDashboardConfigServiceServer) GetMeta(context.Context, *DashboardConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedDashboardConfigServiceServer) SubscribeMeta(*DashboardConfigStreamRequest, DashboardConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedDashboardConfigServiceServer) Set(context.Context, *DashboardConfigSetRequest) (*DashboardConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedDashboardConfigServiceServer) SetSome(*DashboardConfigSetSomeRequest, DashboardConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedDashboardConfigServiceServer) Delete(context.Context, *DashboardConfigDeleteRequest) (*DashboardConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedDashboardConfigServiceServer) DeleteSome(*DashboardConfigDeleteSomeRequest, DashboardConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedDashboardConfigServiceServer) DeleteAll(*DashboardConfigDeleteAllRequest, DashboardConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedDashboardConfigServiceServer) mustEmbedUnimplementedDashboardConfigServiceServer() {
}

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

func RegisterDashboardConfigServiceServer(s grpc.ServiceRegistrar, srv DashboardConfigServiceServer) {
	s.RegisterService(&DashboardConfigService_ServiceDesc, srv)
}

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

func _DashboardConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).GetSome(m, &dashboardConfigServiceGetSomeServer{stream})
}

type DashboardConfigService_GetSomeServer interface {
	Send(*DashboardConfigSomeResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceGetSomeServer) Send(m *DashboardConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DashboardConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).GetAll(m, &dashboardConfigServiceGetAllServer{stream})
}

type DashboardConfigService_GetAllServer interface {
	Send(*DashboardConfigStreamResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceGetAllServer) Send(m *DashboardConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DashboardConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).Subscribe(m, &dashboardConfigServiceSubscribeServer{stream})
}

type DashboardConfigService_SubscribeServer interface {
	Send(*DashboardConfigStreamResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceSubscribeServer) Send(m *DashboardConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _DashboardConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).SubscribeMeta(m, &dashboardConfigServiceSubscribeMetaServer{stream})
}

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

type dashboardConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _DashboardConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).SetSome(m, &dashboardConfigServiceSetSomeServer{stream})
}

type DashboardConfigService_SetSomeServer interface {
	Send(*DashboardConfigSetSomeResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceSetSomeServer) Send(m *DashboardConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _DashboardConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).DeleteSome(m, &dashboardConfigServiceDeleteSomeServer{stream})
}

type DashboardConfigService_DeleteSomeServer interface {
	Send(*DashboardConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceDeleteSomeServer) Send(m *DashboardConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DashboardConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardConfigServiceServer).DeleteAll(m, &dashboardConfigServiceDeleteAllServer{stream})
}

type DashboardConfigService_DeleteAllServer interface {
	Send(*DashboardConfigDeleteAllResponse) error
	grpc.ServerStream
}

type dashboardConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *dashboardConfigServiceDeleteAllServer) Send(m *DashboardConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// DashboardConfigService_ServiceDesc is the grpc.ServiceDesc for DashboardConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DashboardConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.dashboard.v1.DashboardConfigService",
	HandlerType: (*DashboardConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _DashboardConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _DashboardConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _DashboardConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _DashboardConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _DashboardConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _DashboardConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _DashboardConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _DashboardConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _DashboardConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _DashboardConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _DashboardConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/dashboard.v1/services.gen.proto",
}

const (
	GlobalDashboardConfigService_GetOne_FullMethodName        = "/arista.dashboard.v1.GlobalDashboardConfigService/GetOne"
	GlobalDashboardConfigService_GetAll_FullMethodName        = "/arista.dashboard.v1.GlobalDashboardConfigService/GetAll"
	GlobalDashboardConfigService_Subscribe_FullMethodName     = "/arista.dashboard.v1.GlobalDashboardConfigService/Subscribe"
	GlobalDashboardConfigService_SubscribeMeta_FullMethodName = "/arista.dashboard.v1.GlobalDashboardConfigService/SubscribeMeta"
	GlobalDashboardConfigService_Set_FullMethodName           = "/arista.dashboard.v1.GlobalDashboardConfigService/Set"
)

// GlobalDashboardConfigServiceClient is the client API for GlobalDashboardConfigService 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 GlobalDashboardConfigServiceClient interface {
	GetOne(ctx context.Context, in *GlobalDashboardConfigRequest, opts ...grpc.CallOption) (*GlobalDashboardConfigResponse, error)
	GetAll(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_SubscribeClient, error)
	SubscribeMeta(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *GlobalDashboardConfigSetRequest, opts ...grpc.CallOption) (*GlobalDashboardConfigSetResponse, error)
}

type globalDashboardConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGlobalDashboardConfigServiceClient(cc grpc.ClientConnInterface) GlobalDashboardConfigServiceClient {
	return &globalDashboardConfigServiceClient{cc}
}

func (c *globalDashboardConfigServiceClient) GetOne(ctx context.Context, in *GlobalDashboardConfigRequest, opts ...grpc.CallOption) (*GlobalDashboardConfigResponse, error) {
	out := new(GlobalDashboardConfigResponse)
	err := c.cc.Invoke(ctx, GlobalDashboardConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *globalDashboardConfigServiceClient) GetAll(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &GlobalDashboardConfigService_ServiceDesc.Streams[0], GlobalDashboardConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &globalDashboardConfigServiceGetAllClient{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 GlobalDashboardConfigService_GetAllClient interface {
	Recv() (*GlobalDashboardConfigStreamResponse, error)
	grpc.ClientStream
}

type globalDashboardConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *globalDashboardConfigServiceClient) Subscribe(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &GlobalDashboardConfigService_ServiceDesc.Streams[1], GlobalDashboardConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &globalDashboardConfigServiceSubscribeClient{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 GlobalDashboardConfigService_SubscribeClient interface {
	Recv() (*GlobalDashboardConfigStreamResponse, error)
	grpc.ClientStream
}

type globalDashboardConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *globalDashboardConfigServiceClient) SubscribeMeta(ctx context.Context, in *GlobalDashboardConfigStreamRequest, opts ...grpc.CallOption) (GlobalDashboardConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &GlobalDashboardConfigService_ServiceDesc.Streams[2], GlobalDashboardConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &globalDashboardConfigServiceSubscribeMetaClient{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 GlobalDashboardConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type globalDashboardConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *globalDashboardConfigServiceClient) Set(ctx context.Context, in *GlobalDashboardConfigSetRequest, opts ...grpc.CallOption) (*GlobalDashboardConfigSetResponse, error) {
	out := new(GlobalDashboardConfigSetResponse)
	err := c.cc.Invoke(ctx, GlobalDashboardConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GlobalDashboardConfigServiceServer is the server API for GlobalDashboardConfigService service.
// All implementations must embed UnimplementedGlobalDashboardConfigServiceServer
// for forward compatibility
type GlobalDashboardConfigServiceServer interface {
	GetOne(context.Context, *GlobalDashboardConfigRequest) (*GlobalDashboardConfigResponse, error)
	GetAll(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_GetAllServer) error
	Subscribe(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_SubscribeServer) error
	SubscribeMeta(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_SubscribeMetaServer) error
	Set(context.Context, *GlobalDashboardConfigSetRequest) (*GlobalDashboardConfigSetResponse, error)
	mustEmbedUnimplementedGlobalDashboardConfigServiceServer()
}

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

func (UnimplementedGlobalDashboardConfigServiceServer) GetOne(context.Context, *GlobalDashboardConfigRequest) (*GlobalDashboardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedGlobalDashboardConfigServiceServer) GetAll(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedGlobalDashboardConfigServiceServer) Subscribe(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedGlobalDashboardConfigServiceServer) SubscribeMeta(*GlobalDashboardConfigStreamRequest, GlobalDashboardConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedGlobalDashboardConfigServiceServer) Set(context.Context, *GlobalDashboardConfigSetRequest) (*GlobalDashboardConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedGlobalDashboardConfigServiceServer) mustEmbedUnimplementedGlobalDashboardConfigServiceServer() {
}

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

func RegisterGlobalDashboardConfigServiceServer(s grpc.ServiceRegistrar, srv GlobalDashboardConfigServiceServer) {
	s.RegisterService(&GlobalDashboardConfigService_ServiceDesc, srv)
}

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

func _GlobalDashboardConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GlobalDashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GlobalDashboardConfigServiceServer).GetAll(m, &globalDashboardConfigServiceGetAllServer{stream})
}

type GlobalDashboardConfigService_GetAllServer interface {
	Send(*GlobalDashboardConfigStreamResponse) error
	grpc.ServerStream
}

type globalDashboardConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *globalDashboardConfigServiceGetAllServer) Send(m *GlobalDashboardConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GlobalDashboardConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GlobalDashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GlobalDashboardConfigServiceServer).Subscribe(m, &globalDashboardConfigServiceSubscribeServer{stream})
}

type GlobalDashboardConfigService_SubscribeServer interface {
	Send(*GlobalDashboardConfigStreamResponse) error
	grpc.ServerStream
}

type globalDashboardConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *globalDashboardConfigServiceSubscribeServer) Send(m *GlobalDashboardConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GlobalDashboardConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GlobalDashboardConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GlobalDashboardConfigServiceServer).SubscribeMeta(m, &globalDashboardConfigServiceSubscribeMetaServer{stream})
}

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

type globalDashboardConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

// GlobalDashboardConfigService_ServiceDesc is the grpc.ServiceDesc for GlobalDashboardConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GlobalDashboardConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.dashboard.v1.GlobalDashboardConfigService",
	HandlerType: (*GlobalDashboardConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _GlobalDashboardConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _GlobalDashboardConfigService_Set_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _GlobalDashboardConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _GlobalDashboardConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _GlobalDashboardConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/dashboard.v1/services.gen.proto",
}