services.gen_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package clouddeploy_v1

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

// AWSTgwServiceClient is the client API for AWSTgwService 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 AWSTgwServiceClient interface {
	GetOne(ctx context.Context, in *AWSTgwRequest, opts ...grpc.CallOption) (*AWSTgwResponse, error)
	GetAll(ctx context.Context, in *AWSTgwStreamRequest, opts ...grpc.CallOption) (AWSTgwService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AWSTgwStreamRequest, opts ...grpc.CallOption) (AWSTgwService_SubscribeClient, error)
}

type aWSTgwServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAWSTgwServiceClient(cc grpc.ClientConnInterface) AWSTgwServiceClient {
	return &aWSTgwServiceClient{cc}
}

func (c *aWSTgwServiceClient) GetOne(ctx context.Context, in *AWSTgwRequest, opts ...grpc.CallOption) (*AWSTgwResponse, error) {
	out := new(AWSTgwResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.AWSTgwService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aWSTgwServiceClient) GetAll(ctx context.Context, in *AWSTgwStreamRequest, opts ...grpc.CallOption) (AWSTgwService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSTgwService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.AWSTgwService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSTgwServiceGetAllClient{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 AWSTgwService_GetAllClient interface {
	Recv() (*AWSTgwStreamResponse, error)
	grpc.ClientStream
}

type aWSTgwServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *aWSTgwServiceClient) Subscribe(ctx context.Context, in *AWSTgwStreamRequest, opts ...grpc.CallOption) (AWSTgwService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSTgwService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.AWSTgwService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSTgwServiceSubscribeClient{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 AWSTgwService_SubscribeClient interface {
	Recv() (*AWSTgwStreamResponse, error)
	grpc.ClientStream
}

type aWSTgwServiceSubscribeClient struct {
	grpc.ClientStream
}

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

// AWSTgwServiceServer is the server API for AWSTgwService service.
// All implementations must embed UnimplementedAWSTgwServiceServer
// for forward compatibility
type AWSTgwServiceServer interface {
	GetOne(context.Context, *AWSTgwRequest) (*AWSTgwResponse, error)
	GetAll(*AWSTgwStreamRequest, AWSTgwService_GetAllServer) error
	Subscribe(*AWSTgwStreamRequest, AWSTgwService_SubscribeServer) error
	mustEmbedUnimplementedAWSTgwServiceServer()
}

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

func (UnimplementedAWSTgwServiceServer) GetOne(context.Context, *AWSTgwRequest) (*AWSTgwResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAWSTgwServiceServer) GetAll(*AWSTgwStreamRequest, AWSTgwService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAWSTgwServiceServer) Subscribe(*AWSTgwStreamRequest, AWSTgwService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAWSTgwServiceServer) mustEmbedUnimplementedAWSTgwServiceServer() {}

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

func RegisterAWSTgwServiceServer(s grpc.ServiceRegistrar, srv AWSTgwServiceServer) {
	s.RegisterService(&AWSTgwService_ServiceDesc, srv)
}

func _AWSTgwService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AWSTgwRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AWSTgwServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.AWSTgwService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AWSTgwServiceServer).GetOne(ctx, req.(*AWSTgwRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AWSTgwService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSTgwStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSTgwServiceServer).GetAll(m, &aWSTgwServiceGetAllServer{stream})
}

type AWSTgwService_GetAllServer interface {
	Send(*AWSTgwStreamResponse) error
	grpc.ServerStream
}

type aWSTgwServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *aWSTgwServiceGetAllServer) Send(m *AWSTgwStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AWSTgwService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSTgwStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSTgwServiceServer).Subscribe(m, &aWSTgwServiceSubscribeServer{stream})
}

type AWSTgwService_SubscribeServer interface {
	Send(*AWSTgwStreamResponse) error
	grpc.ServerStream
}

type aWSTgwServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *aWSTgwServiceSubscribeServer) Send(m *AWSTgwStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AWSTgwService_ServiceDesc is the grpc.ServiceDesc for AWSTgwService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AWSTgwService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.AWSTgwService",
	HandlerType: (*AWSTgwServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AWSTgwService_GetOne_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _AWSTgwService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AWSTgwService_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// AWSTgwAttachmentServiceClient is the client API for AWSTgwAttachmentService 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 AWSTgwAttachmentServiceClient interface {
	GetOne(ctx context.Context, in *AWSTgwAttachmentRequest, opts ...grpc.CallOption) (*AWSTgwAttachmentResponse, error)
	GetAll(ctx context.Context, in *AWSTgwAttachmentStreamRequest, opts ...grpc.CallOption) (AWSTgwAttachmentService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AWSTgwAttachmentStreamRequest, opts ...grpc.CallOption) (AWSTgwAttachmentService_SubscribeClient, error)
}

type aWSTgwAttachmentServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAWSTgwAttachmentServiceClient(cc grpc.ClientConnInterface) AWSTgwAttachmentServiceClient {
	return &aWSTgwAttachmentServiceClient{cc}
}

func (c *aWSTgwAttachmentServiceClient) GetOne(ctx context.Context, in *AWSTgwAttachmentRequest, opts ...grpc.CallOption) (*AWSTgwAttachmentResponse, error) {
	out := new(AWSTgwAttachmentResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.AWSTgwAttachmentService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aWSTgwAttachmentServiceClient) GetAll(ctx context.Context, in *AWSTgwAttachmentStreamRequest, opts ...grpc.CallOption) (AWSTgwAttachmentService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSTgwAttachmentService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.AWSTgwAttachmentService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSTgwAttachmentServiceGetAllClient{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 AWSTgwAttachmentService_GetAllClient interface {
	Recv() (*AWSTgwAttachmentStreamResponse, error)
	grpc.ClientStream
}

type aWSTgwAttachmentServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *aWSTgwAttachmentServiceClient) Subscribe(ctx context.Context, in *AWSTgwAttachmentStreamRequest, opts ...grpc.CallOption) (AWSTgwAttachmentService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSTgwAttachmentService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.AWSTgwAttachmentService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSTgwAttachmentServiceSubscribeClient{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 AWSTgwAttachmentService_SubscribeClient interface {
	Recv() (*AWSTgwAttachmentStreamResponse, error)
	grpc.ClientStream
}

type aWSTgwAttachmentServiceSubscribeClient struct {
	grpc.ClientStream
}

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

// AWSTgwAttachmentServiceServer is the server API for AWSTgwAttachmentService service.
// All implementations must embed UnimplementedAWSTgwAttachmentServiceServer
// for forward compatibility
type AWSTgwAttachmentServiceServer interface {
	GetOne(context.Context, *AWSTgwAttachmentRequest) (*AWSTgwAttachmentResponse, error)
	GetAll(*AWSTgwAttachmentStreamRequest, AWSTgwAttachmentService_GetAllServer) error
	Subscribe(*AWSTgwAttachmentStreamRequest, AWSTgwAttachmentService_SubscribeServer) error
	mustEmbedUnimplementedAWSTgwAttachmentServiceServer()
}

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

func (UnimplementedAWSTgwAttachmentServiceServer) GetOne(context.Context, *AWSTgwAttachmentRequest) (*AWSTgwAttachmentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAWSTgwAttachmentServiceServer) GetAll(*AWSTgwAttachmentStreamRequest, AWSTgwAttachmentService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAWSTgwAttachmentServiceServer) Subscribe(*AWSTgwAttachmentStreamRequest, AWSTgwAttachmentService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAWSTgwAttachmentServiceServer) mustEmbedUnimplementedAWSTgwAttachmentServiceServer() {
}

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

func RegisterAWSTgwAttachmentServiceServer(s grpc.ServiceRegistrar, srv AWSTgwAttachmentServiceServer) {
	s.RegisterService(&AWSTgwAttachmentService_ServiceDesc, srv)
}

func _AWSTgwAttachmentService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AWSTgwAttachmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AWSTgwAttachmentServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.AWSTgwAttachmentService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AWSTgwAttachmentServiceServer).GetOne(ctx, req.(*AWSTgwAttachmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AWSTgwAttachmentService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSTgwAttachmentStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSTgwAttachmentServiceServer).GetAll(m, &aWSTgwAttachmentServiceGetAllServer{stream})
}

type AWSTgwAttachmentService_GetAllServer interface {
	Send(*AWSTgwAttachmentStreamResponse) error
	grpc.ServerStream
}

type aWSTgwAttachmentServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *aWSTgwAttachmentServiceGetAllServer) Send(m *AWSTgwAttachmentStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AWSTgwAttachmentService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSTgwAttachmentStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSTgwAttachmentServiceServer).Subscribe(m, &aWSTgwAttachmentServiceSubscribeServer{stream})
}

type AWSTgwAttachmentService_SubscribeServer interface {
	Send(*AWSTgwAttachmentStreamResponse) error
	grpc.ServerStream
}

type aWSTgwAttachmentServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *aWSTgwAttachmentServiceSubscribeServer) Send(m *AWSTgwAttachmentStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AWSTgwAttachmentService_ServiceDesc is the grpc.ServiceDesc for AWSTgwAttachmentService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AWSTgwAttachmentService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.AWSTgwAttachmentService",
	HandlerType: (*AWSTgwAttachmentServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AWSTgwAttachmentService_GetOne_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _AWSTgwAttachmentService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AWSTgwAttachmentService_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// AWSVpnConfigServiceClient is the client API for AWSVpnConfigService 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 AWSVpnConfigServiceClient interface {
	GetOne(ctx context.Context, in *AWSVpnConfigRequest, opts ...grpc.CallOption) (*AWSVpnConfigResponse, error)
	GetAll(ctx context.Context, in *AWSVpnConfigStreamRequest, opts ...grpc.CallOption) (AWSVpnConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AWSVpnConfigStreamRequest, opts ...grpc.CallOption) (AWSVpnConfigService_SubscribeClient, error)
	Set(ctx context.Context, in *AWSVpnConfigSetRequest, opts ...grpc.CallOption) (*AWSVpnConfigSetResponse, error)
	SetSome(ctx context.Context, in *AWSVpnConfigSetSomeRequest, opts ...grpc.CallOption) (AWSVpnConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *AWSVpnConfigDeleteRequest, opts ...grpc.CallOption) (*AWSVpnConfigDeleteResponse, error)
	DeleteAll(ctx context.Context, in *AWSVpnConfigDeleteAllRequest, opts ...grpc.CallOption) (AWSVpnConfigService_DeleteAllClient, error)
}

type aWSVpnConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAWSVpnConfigServiceClient(cc grpc.ClientConnInterface) AWSVpnConfigServiceClient {
	return &aWSVpnConfigServiceClient{cc}
}

func (c *aWSVpnConfigServiceClient) GetOne(ctx context.Context, in *AWSVpnConfigRequest, opts ...grpc.CallOption) (*AWSVpnConfigResponse, error) {
	out := new(AWSVpnConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.AWSVpnConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aWSVpnConfigServiceClient) GetAll(ctx context.Context, in *AWSVpnConfigStreamRequest, opts ...grpc.CallOption) (AWSVpnConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSVpnConfigService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.AWSVpnConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSVpnConfigServiceGetAllClient{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 AWSVpnConfigService_GetAllClient interface {
	Recv() (*AWSVpnConfigStreamResponse, error)
	grpc.ClientStream
}

type aWSVpnConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *aWSVpnConfigServiceClient) Subscribe(ctx context.Context, in *AWSVpnConfigStreamRequest, opts ...grpc.CallOption) (AWSVpnConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSVpnConfigService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.AWSVpnConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSVpnConfigServiceSubscribeClient{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 AWSVpnConfigService_SubscribeClient interface {
	Recv() (*AWSVpnConfigStreamResponse, error)
	grpc.ClientStream
}

type aWSVpnConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *aWSVpnConfigServiceClient) Set(ctx context.Context, in *AWSVpnConfigSetRequest, opts ...grpc.CallOption) (*AWSVpnConfigSetResponse, error) {
	out := new(AWSVpnConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.AWSVpnConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aWSVpnConfigServiceClient) SetSome(ctx context.Context, in *AWSVpnConfigSetSomeRequest, opts ...grpc.CallOption) (AWSVpnConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSVpnConfigService_ServiceDesc.Streams[2], "/arista.clouddeploy.v1.AWSVpnConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSVpnConfigServiceSetSomeClient{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 AWSVpnConfigService_SetSomeClient interface {
	Recv() (*AWSVpnConfigSetSomeResponse, error)
	grpc.ClientStream
}

type aWSVpnConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *aWSVpnConfigServiceClient) Delete(ctx context.Context, in *AWSVpnConfigDeleteRequest, opts ...grpc.CallOption) (*AWSVpnConfigDeleteResponse, error) {
	out := new(AWSVpnConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.AWSVpnConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aWSVpnConfigServiceClient) DeleteAll(ctx context.Context, in *AWSVpnConfigDeleteAllRequest, opts ...grpc.CallOption) (AWSVpnConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AWSVpnConfigService_ServiceDesc.Streams[3], "/arista.clouddeploy.v1.AWSVpnConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &aWSVpnConfigServiceDeleteAllClient{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 AWSVpnConfigService_DeleteAllClient interface {
	Recv() (*AWSVpnConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type aWSVpnConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// AWSVpnConfigServiceServer is the server API for AWSVpnConfigService service.
// All implementations must embed UnimplementedAWSVpnConfigServiceServer
// for forward compatibility
type AWSVpnConfigServiceServer interface {
	GetOne(context.Context, *AWSVpnConfigRequest) (*AWSVpnConfigResponse, error)
	GetAll(*AWSVpnConfigStreamRequest, AWSVpnConfigService_GetAllServer) error
	Subscribe(*AWSVpnConfigStreamRequest, AWSVpnConfigService_SubscribeServer) error
	Set(context.Context, *AWSVpnConfigSetRequest) (*AWSVpnConfigSetResponse, error)
	SetSome(*AWSVpnConfigSetSomeRequest, AWSVpnConfigService_SetSomeServer) error
	Delete(context.Context, *AWSVpnConfigDeleteRequest) (*AWSVpnConfigDeleteResponse, error)
	DeleteAll(*AWSVpnConfigDeleteAllRequest, AWSVpnConfigService_DeleteAllServer) error
	mustEmbedUnimplementedAWSVpnConfigServiceServer()
}

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

func (UnimplementedAWSVpnConfigServiceServer) GetOne(context.Context, *AWSVpnConfigRequest) (*AWSVpnConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) GetAll(*AWSVpnConfigStreamRequest, AWSVpnConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) Subscribe(*AWSVpnConfigStreamRequest, AWSVpnConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) Set(context.Context, *AWSVpnConfigSetRequest) (*AWSVpnConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) SetSome(*AWSVpnConfigSetSomeRequest, AWSVpnConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) Delete(context.Context, *AWSVpnConfigDeleteRequest) (*AWSVpnConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) DeleteAll(*AWSVpnConfigDeleteAllRequest, AWSVpnConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedAWSVpnConfigServiceServer) mustEmbedUnimplementedAWSVpnConfigServiceServer() {}

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

func RegisterAWSVpnConfigServiceServer(s grpc.ServiceRegistrar, srv AWSVpnConfigServiceServer) {
	s.RegisterService(&AWSVpnConfigService_ServiceDesc, srv)
}

func _AWSVpnConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AWSVpnConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AWSVpnConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.AWSVpnConfigService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AWSVpnConfigServiceServer).GetOne(ctx, req.(*AWSVpnConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AWSVpnConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSVpnConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSVpnConfigServiceServer).GetAll(m, &aWSVpnConfigServiceGetAllServer{stream})
}

type AWSVpnConfigService_GetAllServer interface {
	Send(*AWSVpnConfigStreamResponse) error
	grpc.ServerStream
}

type aWSVpnConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *aWSVpnConfigServiceGetAllServer) Send(m *AWSVpnConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AWSVpnConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSVpnConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSVpnConfigServiceServer).Subscribe(m, &aWSVpnConfigServiceSubscribeServer{stream})
}

type AWSVpnConfigService_SubscribeServer interface {
	Send(*AWSVpnConfigStreamResponse) error
	grpc.ServerStream
}

type aWSVpnConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *aWSVpnConfigServiceSubscribeServer) Send(m *AWSVpnConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AWSVpnConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AWSVpnConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AWSVpnConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.AWSVpnConfigService/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AWSVpnConfigServiceServer).Set(ctx, req.(*AWSVpnConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AWSVpnConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSVpnConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSVpnConfigServiceServer).SetSome(m, &aWSVpnConfigServiceSetSomeServer{stream})
}

type AWSVpnConfigService_SetSomeServer interface {
	Send(*AWSVpnConfigSetSomeResponse) error
	grpc.ServerStream
}

type aWSVpnConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *aWSVpnConfigServiceSetSomeServer) Send(m *AWSVpnConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AWSVpnConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AWSVpnConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AWSVpnConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.AWSVpnConfigService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AWSVpnConfigServiceServer).Delete(ctx, req.(*AWSVpnConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AWSVpnConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AWSVpnConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AWSVpnConfigServiceServer).DeleteAll(m, &aWSVpnConfigServiceDeleteAllServer{stream})
}

type AWSVpnConfigService_DeleteAllServer interface {
	Send(*AWSVpnConfigDeleteAllResponse) error
	grpc.ServerStream
}

type aWSVpnConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *aWSVpnConfigServiceDeleteAllServer) Send(m *AWSVpnConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AWSVpnConfigService_ServiceDesc is the grpc.ServiceDesc for AWSVpnConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AWSVpnConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.AWSVpnConfigService",
	HandlerType: (*AWSVpnConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AWSVpnConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _AWSVpnConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _AWSVpnConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _AWSVpnConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AWSVpnConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _AWSVpnConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _AWSVpnConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// PathServiceClient is the client API for PathService 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 PathServiceClient interface {
	GetOne(ctx context.Context, in *PathRequest, opts ...grpc.CallOption) (*PathResponse, error)
	GetAll(ctx context.Context, in *PathStreamRequest, opts ...grpc.CallOption) (PathService_GetAllClient, error)
	Subscribe(ctx context.Context, in *PathStreamRequest, opts ...grpc.CallOption) (PathService_SubscribeClient, error)
}

type pathServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewPathServiceClient(cc grpc.ClientConnInterface) PathServiceClient {
	return &pathServiceClient{cc}
}

func (c *pathServiceClient) GetOne(ctx context.Context, in *PathRequest, opts ...grpc.CallOption) (*PathResponse, error) {
	out := new(PathResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.PathService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pathServiceClient) GetAll(ctx context.Context, in *PathStreamRequest, opts ...grpc.CallOption) (PathService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &PathService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.PathService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &pathServiceGetAllClient{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 PathService_GetAllClient interface {
	Recv() (*PathStreamResponse, error)
	grpc.ClientStream
}

type pathServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *pathServiceClient) Subscribe(ctx context.Context, in *PathStreamRequest, opts ...grpc.CallOption) (PathService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &PathService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.PathService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &pathServiceSubscribeClient{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 PathService_SubscribeClient interface {
	Recv() (*PathStreamResponse, error)
	grpc.ClientStream
}

type pathServiceSubscribeClient struct {
	grpc.ClientStream
}

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

// PathServiceServer is the server API for PathService service.
// All implementations must embed UnimplementedPathServiceServer
// for forward compatibility
type PathServiceServer interface {
	GetOne(context.Context, *PathRequest) (*PathResponse, error)
	GetAll(*PathStreamRequest, PathService_GetAllServer) error
	Subscribe(*PathStreamRequest, PathService_SubscribeServer) error
	mustEmbedUnimplementedPathServiceServer()
}

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

func (UnimplementedPathServiceServer) GetOne(context.Context, *PathRequest) (*PathResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedPathServiceServer) GetAll(*PathStreamRequest, PathService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedPathServiceServer) Subscribe(*PathStreamRequest, PathService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedPathServiceServer) mustEmbedUnimplementedPathServiceServer() {}

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

func RegisterPathServiceServer(s grpc.ServiceRegistrar, srv PathServiceServer) {
	s.RegisterService(&PathService_ServiceDesc, srv)
}

func _PathService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PathServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.PathService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PathServiceServer).GetOne(ctx, req.(*PathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PathService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PathStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PathServiceServer).GetAll(m, &pathServiceGetAllServer{stream})
}

type PathService_GetAllServer interface {
	Send(*PathStreamResponse) error
	grpc.ServerStream
}

type pathServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *pathServiceGetAllServer) Send(m *PathStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _PathService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PathStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PathServiceServer).Subscribe(m, &pathServiceSubscribeServer{stream})
}

type PathService_SubscribeServer interface {
	Send(*PathStreamResponse) error
	grpc.ServerStream
}

type pathServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *pathServiceSubscribeServer) Send(m *PathStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// PathService_ServiceDesc is the grpc.ServiceDesc for PathService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PathService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.PathService",
	HandlerType: (*PathServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _PathService_GetOne_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _PathService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _PathService_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// RouterConfigServiceClient is the client API for RouterConfigService 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 RouterConfigServiceClient interface {
	GetOne(ctx context.Context, in *RouterConfigRequest, opts ...grpc.CallOption) (*RouterConfigResponse, error)
	GetAll(ctx context.Context, in *RouterConfigStreamRequest, opts ...grpc.CallOption) (RouterConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *RouterConfigStreamRequest, opts ...grpc.CallOption) (RouterConfigService_SubscribeClient, error)
	Set(ctx context.Context, in *RouterConfigSetRequest, opts ...grpc.CallOption) (*RouterConfigSetResponse, error)
	SetSome(ctx context.Context, in *RouterConfigSetSomeRequest, opts ...grpc.CallOption) (RouterConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *RouterConfigDeleteRequest, opts ...grpc.CallOption) (*RouterConfigDeleteResponse, error)
	DeleteAll(ctx context.Context, in *RouterConfigDeleteAllRequest, opts ...grpc.CallOption) (RouterConfigService_DeleteAllClient, error)
}

type routerConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRouterConfigServiceClient(cc grpc.ClientConnInterface) RouterConfigServiceClient {
	return &routerConfigServiceClient{cc}
}

func (c *routerConfigServiceClient) GetOne(ctx context.Context, in *RouterConfigRequest, opts ...grpc.CallOption) (*RouterConfigResponse, error) {
	out := new(RouterConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.RouterConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routerConfigServiceClient) GetAll(ctx context.Context, in *RouterConfigStreamRequest, opts ...grpc.CallOption) (RouterConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &RouterConfigService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.RouterConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerConfigServiceGetAllClient{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 RouterConfigService_GetAllClient interface {
	Recv() (*RouterConfigStreamResponse, error)
	grpc.ClientStream
}

type routerConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *routerConfigServiceClient) Subscribe(ctx context.Context, in *RouterConfigStreamRequest, opts ...grpc.CallOption) (RouterConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &RouterConfigService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.RouterConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerConfigServiceSubscribeClient{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 RouterConfigService_SubscribeClient interface {
	Recv() (*RouterConfigStreamResponse, error)
	grpc.ClientStream
}

type routerConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *routerConfigServiceClient) Set(ctx context.Context, in *RouterConfigSetRequest, opts ...grpc.CallOption) (*RouterConfigSetResponse, error) {
	out := new(RouterConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.RouterConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routerConfigServiceClient) SetSome(ctx context.Context, in *RouterConfigSetSomeRequest, opts ...grpc.CallOption) (RouterConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &RouterConfigService_ServiceDesc.Streams[2], "/arista.clouddeploy.v1.RouterConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerConfigServiceSetSomeClient{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 RouterConfigService_SetSomeClient interface {
	Recv() (*RouterConfigSetSomeResponse, error)
	grpc.ClientStream
}

type routerConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *routerConfigServiceClient) Delete(ctx context.Context, in *RouterConfigDeleteRequest, opts ...grpc.CallOption) (*RouterConfigDeleteResponse, error) {
	out := new(RouterConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.RouterConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *routerConfigServiceClient) DeleteAll(ctx context.Context, in *RouterConfigDeleteAllRequest, opts ...grpc.CallOption) (RouterConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &RouterConfigService_ServiceDesc.Streams[3], "/arista.clouddeploy.v1.RouterConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerConfigServiceDeleteAllClient{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 RouterConfigService_DeleteAllClient interface {
	Recv() (*RouterConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type routerConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// RouterConfigServiceServer is the server API for RouterConfigService service.
// All implementations must embed UnimplementedRouterConfigServiceServer
// for forward compatibility
type RouterConfigServiceServer interface {
	GetOne(context.Context, *RouterConfigRequest) (*RouterConfigResponse, error)
	GetAll(*RouterConfigStreamRequest, RouterConfigService_GetAllServer) error
	Subscribe(*RouterConfigStreamRequest, RouterConfigService_SubscribeServer) error
	Set(context.Context, *RouterConfigSetRequest) (*RouterConfigSetResponse, error)
	SetSome(*RouterConfigSetSomeRequest, RouterConfigService_SetSomeServer) error
	Delete(context.Context, *RouterConfigDeleteRequest) (*RouterConfigDeleteResponse, error)
	DeleteAll(*RouterConfigDeleteAllRequest, RouterConfigService_DeleteAllServer) error
	mustEmbedUnimplementedRouterConfigServiceServer()
}

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

func (UnimplementedRouterConfigServiceServer) GetOne(context.Context, *RouterConfigRequest) (*RouterConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedRouterConfigServiceServer) GetAll(*RouterConfigStreamRequest, RouterConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedRouterConfigServiceServer) Subscribe(*RouterConfigStreamRequest, RouterConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedRouterConfigServiceServer) Set(context.Context, *RouterConfigSetRequest) (*RouterConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedRouterConfigServiceServer) SetSome(*RouterConfigSetSomeRequest, RouterConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedRouterConfigServiceServer) Delete(context.Context, *RouterConfigDeleteRequest) (*RouterConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedRouterConfigServiceServer) DeleteAll(*RouterConfigDeleteAllRequest, RouterConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedRouterConfigServiceServer) mustEmbedUnimplementedRouterConfigServiceServer() {}

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

func RegisterRouterConfigServiceServer(s grpc.ServiceRegistrar, srv RouterConfigServiceServer) {
	s.RegisterService(&RouterConfigService_ServiceDesc, srv)
}

func _RouterConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouterConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.RouterConfigService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterConfigServiceServer).GetOne(ctx, req.(*RouterConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouterConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RouterConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterConfigServiceServer).GetAll(m, &routerConfigServiceGetAllServer{stream})
}

type RouterConfigService_GetAllServer interface {
	Send(*RouterConfigStreamResponse) error
	grpc.ServerStream
}

type routerConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *routerConfigServiceGetAllServer) Send(m *RouterConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _RouterConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RouterConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterConfigServiceServer).Subscribe(m, &routerConfigServiceSubscribeServer{stream})
}

type RouterConfigService_SubscribeServer interface {
	Send(*RouterConfigStreamResponse) error
	grpc.ServerStream
}

type routerConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *routerConfigServiceSubscribeServer) Send(m *RouterConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _RouterConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouterConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.RouterConfigService/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterConfigServiceServer).Set(ctx, req.(*RouterConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouterConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RouterConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterConfigServiceServer).SetSome(m, &routerConfigServiceSetSomeServer{stream})
}

type RouterConfigService_SetSomeServer interface {
	Send(*RouterConfigSetSomeResponse) error
	grpc.ServerStream
}

type routerConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *routerConfigServiceSetSomeServer) Send(m *RouterConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _RouterConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouterConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.RouterConfigService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterConfigServiceServer).Delete(ctx, req.(*RouterConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouterConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RouterConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterConfigServiceServer).DeleteAll(m, &routerConfigServiceDeleteAllServer{stream})
}

type RouterConfigService_DeleteAllServer interface {
	Send(*RouterConfigDeleteAllResponse) error
	grpc.ServerStream
}

type routerConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *routerConfigServiceDeleteAllServer) Send(m *RouterConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// RouterConfigService_ServiceDesc is the grpc.ServiceDesc for RouterConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RouterConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.RouterConfigService",
	HandlerType: (*RouterConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _RouterConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _RouterConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _RouterConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _RouterConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _RouterConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _RouterConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _RouterConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// SubnetConfigServiceClient is the client API for SubnetConfigService 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 SubnetConfigServiceClient interface {
	GetOne(ctx context.Context, in *SubnetConfigRequest, opts ...grpc.CallOption) (*SubnetConfigResponse, error)
	GetAll(ctx context.Context, in *SubnetConfigStreamRequest, opts ...grpc.CallOption) (SubnetConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *SubnetConfigStreamRequest, opts ...grpc.CallOption) (SubnetConfigService_SubscribeClient, error)
	Set(ctx context.Context, in *SubnetConfigSetRequest, opts ...grpc.CallOption) (*SubnetConfigSetResponse, error)
	SetSome(ctx context.Context, in *SubnetConfigSetSomeRequest, opts ...grpc.CallOption) (SubnetConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *SubnetConfigDeleteRequest, opts ...grpc.CallOption) (*SubnetConfigDeleteResponse, error)
	DeleteAll(ctx context.Context, in *SubnetConfigDeleteAllRequest, opts ...grpc.CallOption) (SubnetConfigService_DeleteAllClient, error)
}

type subnetConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSubnetConfigServiceClient(cc grpc.ClientConnInterface) SubnetConfigServiceClient {
	return &subnetConfigServiceClient{cc}
}

func (c *subnetConfigServiceClient) GetOne(ctx context.Context, in *SubnetConfigRequest, opts ...grpc.CallOption) (*SubnetConfigResponse, error) {
	out := new(SubnetConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.SubnetConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *subnetConfigServiceClient) GetAll(ctx context.Context, in *SubnetConfigStreamRequest, opts ...grpc.CallOption) (SubnetConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &SubnetConfigService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.SubnetConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &subnetConfigServiceGetAllClient{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 SubnetConfigService_GetAllClient interface {
	Recv() (*SubnetConfigStreamResponse, error)
	grpc.ClientStream
}

type subnetConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *subnetConfigServiceClient) Subscribe(ctx context.Context, in *SubnetConfigStreamRequest, opts ...grpc.CallOption) (SubnetConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SubnetConfigService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.SubnetConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &subnetConfigServiceSubscribeClient{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 SubnetConfigService_SubscribeClient interface {
	Recv() (*SubnetConfigStreamResponse, error)
	grpc.ClientStream
}

type subnetConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *subnetConfigServiceClient) Set(ctx context.Context, in *SubnetConfigSetRequest, opts ...grpc.CallOption) (*SubnetConfigSetResponse, error) {
	out := new(SubnetConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.SubnetConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *subnetConfigServiceClient) SetSome(ctx context.Context, in *SubnetConfigSetSomeRequest, opts ...grpc.CallOption) (SubnetConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SubnetConfigService_ServiceDesc.Streams[2], "/arista.clouddeploy.v1.SubnetConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &subnetConfigServiceSetSomeClient{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 SubnetConfigService_SetSomeClient interface {
	Recv() (*SubnetConfigSetSomeResponse, error)
	grpc.ClientStream
}

type subnetConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *subnetConfigServiceClient) Delete(ctx context.Context, in *SubnetConfigDeleteRequest, opts ...grpc.CallOption) (*SubnetConfigDeleteResponse, error) {
	out := new(SubnetConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.SubnetConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *subnetConfigServiceClient) DeleteAll(ctx context.Context, in *SubnetConfigDeleteAllRequest, opts ...grpc.CallOption) (SubnetConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &SubnetConfigService_ServiceDesc.Streams[3], "/arista.clouddeploy.v1.SubnetConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &subnetConfigServiceDeleteAllClient{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 SubnetConfigService_DeleteAllClient interface {
	Recv() (*SubnetConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type subnetConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// SubnetConfigServiceServer is the server API for SubnetConfigService service.
// All implementations must embed UnimplementedSubnetConfigServiceServer
// for forward compatibility
type SubnetConfigServiceServer interface {
	GetOne(context.Context, *SubnetConfigRequest) (*SubnetConfigResponse, error)
	GetAll(*SubnetConfigStreamRequest, SubnetConfigService_GetAllServer) error
	Subscribe(*SubnetConfigStreamRequest, SubnetConfigService_SubscribeServer) error
	Set(context.Context, *SubnetConfigSetRequest) (*SubnetConfigSetResponse, error)
	SetSome(*SubnetConfigSetSomeRequest, SubnetConfigService_SetSomeServer) error
	Delete(context.Context, *SubnetConfigDeleteRequest) (*SubnetConfigDeleteResponse, error)
	DeleteAll(*SubnetConfigDeleteAllRequest, SubnetConfigService_DeleteAllServer) error
	mustEmbedUnimplementedSubnetConfigServiceServer()
}

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

func (UnimplementedSubnetConfigServiceServer) GetOne(context.Context, *SubnetConfigRequest) (*SubnetConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedSubnetConfigServiceServer) GetAll(*SubnetConfigStreamRequest, SubnetConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedSubnetConfigServiceServer) Subscribe(*SubnetConfigStreamRequest, SubnetConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedSubnetConfigServiceServer) Set(context.Context, *SubnetConfigSetRequest) (*SubnetConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedSubnetConfigServiceServer) SetSome(*SubnetConfigSetSomeRequest, SubnetConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedSubnetConfigServiceServer) Delete(context.Context, *SubnetConfigDeleteRequest) (*SubnetConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedSubnetConfigServiceServer) DeleteAll(*SubnetConfigDeleteAllRequest, SubnetConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedSubnetConfigServiceServer) mustEmbedUnimplementedSubnetConfigServiceServer() {}

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

func RegisterSubnetConfigServiceServer(s grpc.ServiceRegistrar, srv SubnetConfigServiceServer) {
	s.RegisterService(&SubnetConfigService_ServiceDesc, srv)
}

func _SubnetConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubnetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SubnetConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.SubnetConfigService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SubnetConfigServiceServer).GetOne(ctx, req.(*SubnetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SubnetConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubnetConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SubnetConfigServiceServer).GetAll(m, &subnetConfigServiceGetAllServer{stream})
}

type SubnetConfigService_GetAllServer interface {
	Send(*SubnetConfigStreamResponse) error
	grpc.ServerStream
}

type subnetConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *subnetConfigServiceGetAllServer) Send(m *SubnetConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SubnetConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubnetConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SubnetConfigServiceServer).Subscribe(m, &subnetConfigServiceSubscribeServer{stream})
}

type SubnetConfigService_SubscribeServer interface {
	Send(*SubnetConfigStreamResponse) error
	grpc.ServerStream
}

type subnetConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *subnetConfigServiceSubscribeServer) Send(m *SubnetConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SubnetConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubnetConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SubnetConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.SubnetConfigService/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SubnetConfigServiceServer).Set(ctx, req.(*SubnetConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SubnetConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubnetConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SubnetConfigServiceServer).SetSome(m, &subnetConfigServiceSetSomeServer{stream})
}

type SubnetConfigService_SetSomeServer interface {
	Send(*SubnetConfigSetSomeResponse) error
	grpc.ServerStream
}

type subnetConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *subnetConfigServiceSetSomeServer) Send(m *SubnetConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SubnetConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubnetConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SubnetConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.SubnetConfigService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SubnetConfigServiceServer).Delete(ctx, req.(*SubnetConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SubnetConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubnetConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SubnetConfigServiceServer).DeleteAll(m, &subnetConfigServiceDeleteAllServer{stream})
}

type SubnetConfigService_DeleteAllServer interface {
	Send(*SubnetConfigDeleteAllResponse) error
	grpc.ServerStream
}

type subnetConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *subnetConfigServiceDeleteAllServer) Send(m *SubnetConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// SubnetConfigService_ServiceDesc is the grpc.ServiceDesc for SubnetConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SubnetConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.SubnetConfigService",
	HandlerType: (*SubnetConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _SubnetConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _SubnetConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _SubnetConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _SubnetConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _SubnetConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _SubnetConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _SubnetConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// TopologyInfoConfigServiceClient is the client API for TopologyInfoConfigService 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 TopologyInfoConfigServiceClient interface {
	GetOne(ctx context.Context, in *TopologyInfoConfigRequest, opts ...grpc.CallOption) (*TopologyInfoConfigResponse, error)
	GetAll(ctx context.Context, in *TopologyInfoConfigStreamRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *TopologyInfoConfigStreamRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_SubscribeClient, error)
	Set(ctx context.Context, in *TopologyInfoConfigSetRequest, opts ...grpc.CallOption) (*TopologyInfoConfigSetResponse, error)
	SetSome(ctx context.Context, in *TopologyInfoConfigSetSomeRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *TopologyInfoConfigDeleteRequest, opts ...grpc.CallOption) (*TopologyInfoConfigDeleteResponse, error)
	DeleteAll(ctx context.Context, in *TopologyInfoConfigDeleteAllRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_DeleteAllClient, error)
}

type topologyInfoConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTopologyInfoConfigServiceClient(cc grpc.ClientConnInterface) TopologyInfoConfigServiceClient {
	return &topologyInfoConfigServiceClient{cc}
}

func (c *topologyInfoConfigServiceClient) GetOne(ctx context.Context, in *TopologyInfoConfigRequest, opts ...grpc.CallOption) (*TopologyInfoConfigResponse, error) {
	out := new(TopologyInfoConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.TopologyInfoConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *topologyInfoConfigServiceClient) GetAll(ctx context.Context, in *TopologyInfoConfigStreamRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &TopologyInfoConfigService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.TopologyInfoConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &topologyInfoConfigServiceGetAllClient{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 TopologyInfoConfigService_GetAllClient interface {
	Recv() (*TopologyInfoConfigStreamResponse, error)
	grpc.ClientStream
}

type topologyInfoConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *topologyInfoConfigServiceClient) Subscribe(ctx context.Context, in *TopologyInfoConfigStreamRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TopologyInfoConfigService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.TopologyInfoConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &topologyInfoConfigServiceSubscribeClient{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 TopologyInfoConfigService_SubscribeClient interface {
	Recv() (*TopologyInfoConfigStreamResponse, error)
	grpc.ClientStream
}

type topologyInfoConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *topologyInfoConfigServiceClient) Set(ctx context.Context, in *TopologyInfoConfigSetRequest, opts ...grpc.CallOption) (*TopologyInfoConfigSetResponse, error) {
	out := new(TopologyInfoConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.TopologyInfoConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *topologyInfoConfigServiceClient) SetSome(ctx context.Context, in *TopologyInfoConfigSetSomeRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TopologyInfoConfigService_ServiceDesc.Streams[2], "/arista.clouddeploy.v1.TopologyInfoConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &topologyInfoConfigServiceSetSomeClient{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 TopologyInfoConfigService_SetSomeClient interface {
	Recv() (*TopologyInfoConfigSetSomeResponse, error)
	grpc.ClientStream
}

type topologyInfoConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *topologyInfoConfigServiceClient) Delete(ctx context.Context, in *TopologyInfoConfigDeleteRequest, opts ...grpc.CallOption) (*TopologyInfoConfigDeleteResponse, error) {
	out := new(TopologyInfoConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.TopologyInfoConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *topologyInfoConfigServiceClient) DeleteAll(ctx context.Context, in *TopologyInfoConfigDeleteAllRequest, opts ...grpc.CallOption) (TopologyInfoConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &TopologyInfoConfigService_ServiceDesc.Streams[3], "/arista.clouddeploy.v1.TopologyInfoConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &topologyInfoConfigServiceDeleteAllClient{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 TopologyInfoConfigService_DeleteAllClient interface {
	Recv() (*TopologyInfoConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type topologyInfoConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// TopologyInfoConfigServiceServer is the server API for TopologyInfoConfigService service.
// All implementations must embed UnimplementedTopologyInfoConfigServiceServer
// for forward compatibility
type TopologyInfoConfigServiceServer interface {
	GetOne(context.Context, *TopologyInfoConfigRequest) (*TopologyInfoConfigResponse, error)
	GetAll(*TopologyInfoConfigStreamRequest, TopologyInfoConfigService_GetAllServer) error
	Subscribe(*TopologyInfoConfigStreamRequest, TopologyInfoConfigService_SubscribeServer) error
	Set(context.Context, *TopologyInfoConfigSetRequest) (*TopologyInfoConfigSetResponse, error)
	SetSome(*TopologyInfoConfigSetSomeRequest, TopologyInfoConfigService_SetSomeServer) error
	Delete(context.Context, *TopologyInfoConfigDeleteRequest) (*TopologyInfoConfigDeleteResponse, error)
	DeleteAll(*TopologyInfoConfigDeleteAllRequest, TopologyInfoConfigService_DeleteAllServer) error
	mustEmbedUnimplementedTopologyInfoConfigServiceServer()
}

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

func (UnimplementedTopologyInfoConfigServiceServer) GetOne(context.Context, *TopologyInfoConfigRequest) (*TopologyInfoConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) GetAll(*TopologyInfoConfigStreamRequest, TopologyInfoConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) Subscribe(*TopologyInfoConfigStreamRequest, TopologyInfoConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) Set(context.Context, *TopologyInfoConfigSetRequest) (*TopologyInfoConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) SetSome(*TopologyInfoConfigSetSomeRequest, TopologyInfoConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) Delete(context.Context, *TopologyInfoConfigDeleteRequest) (*TopologyInfoConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) DeleteAll(*TopologyInfoConfigDeleteAllRequest, TopologyInfoConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedTopologyInfoConfigServiceServer) mustEmbedUnimplementedTopologyInfoConfigServiceServer() {
}

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

func RegisterTopologyInfoConfigServiceServer(s grpc.ServiceRegistrar, srv TopologyInfoConfigServiceServer) {
	s.RegisterService(&TopologyInfoConfigService_ServiceDesc, srv)
}

func _TopologyInfoConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TopologyInfoConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TopologyInfoConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.TopologyInfoConfigService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TopologyInfoConfigServiceServer).GetOne(ctx, req.(*TopologyInfoConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TopologyInfoConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TopologyInfoConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TopologyInfoConfigServiceServer).GetAll(m, &topologyInfoConfigServiceGetAllServer{stream})
}

type TopologyInfoConfigService_GetAllServer interface {
	Send(*TopologyInfoConfigStreamResponse) error
	grpc.ServerStream
}

type topologyInfoConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *topologyInfoConfigServiceGetAllServer) Send(m *TopologyInfoConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TopologyInfoConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TopologyInfoConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TopologyInfoConfigServiceServer).Subscribe(m, &topologyInfoConfigServiceSubscribeServer{stream})
}

type TopologyInfoConfigService_SubscribeServer interface {
	Send(*TopologyInfoConfigStreamResponse) error
	grpc.ServerStream
}

type topologyInfoConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *topologyInfoConfigServiceSubscribeServer) Send(m *TopologyInfoConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TopologyInfoConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TopologyInfoConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TopologyInfoConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.TopologyInfoConfigService/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TopologyInfoConfigServiceServer).Set(ctx, req.(*TopologyInfoConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TopologyInfoConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TopologyInfoConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TopologyInfoConfigServiceServer).SetSome(m, &topologyInfoConfigServiceSetSomeServer{stream})
}

type TopologyInfoConfigService_SetSomeServer interface {
	Send(*TopologyInfoConfigSetSomeResponse) error
	grpc.ServerStream
}

type topologyInfoConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *topologyInfoConfigServiceSetSomeServer) Send(m *TopologyInfoConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TopologyInfoConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TopologyInfoConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TopologyInfoConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.TopologyInfoConfigService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TopologyInfoConfigServiceServer).Delete(ctx, req.(*TopologyInfoConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TopologyInfoConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TopologyInfoConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TopologyInfoConfigServiceServer).DeleteAll(m, &topologyInfoConfigServiceDeleteAllServer{stream})
}

type TopologyInfoConfigService_DeleteAllServer interface {
	Send(*TopologyInfoConfigDeleteAllResponse) error
	grpc.ServerStream
}

type topologyInfoConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *topologyInfoConfigServiceDeleteAllServer) Send(m *TopologyInfoConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// TopologyInfoConfigService_ServiceDesc is the grpc.ServiceDesc for TopologyInfoConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TopologyInfoConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.TopologyInfoConfigService",
	HandlerType: (*TopologyInfoConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _TopologyInfoConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _TopologyInfoConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _TopologyInfoConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _TopologyInfoConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _TopologyInfoConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _TopologyInfoConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _TopologyInfoConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}

// VpcConfigServiceClient is the client API for VpcConfigService 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 VpcConfigServiceClient interface {
	GetOne(ctx context.Context, in *VpcConfigRequest, opts ...grpc.CallOption) (*VpcConfigResponse, error)
	GetAll(ctx context.Context, in *VpcConfigStreamRequest, opts ...grpc.CallOption) (VpcConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *VpcConfigStreamRequest, opts ...grpc.CallOption) (VpcConfigService_SubscribeClient, error)
	Set(ctx context.Context, in *VpcConfigSetRequest, opts ...grpc.CallOption) (*VpcConfigSetResponse, error)
	SetSome(ctx context.Context, in *VpcConfigSetSomeRequest, opts ...grpc.CallOption) (VpcConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *VpcConfigDeleteRequest, opts ...grpc.CallOption) (*VpcConfigDeleteResponse, error)
	DeleteAll(ctx context.Context, in *VpcConfigDeleteAllRequest, opts ...grpc.CallOption) (VpcConfigService_DeleteAllClient, error)
}

type vpcConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewVpcConfigServiceClient(cc grpc.ClientConnInterface) VpcConfigServiceClient {
	return &vpcConfigServiceClient{cc}
}

func (c *vpcConfigServiceClient) GetOne(ctx context.Context, in *VpcConfigRequest, opts ...grpc.CallOption) (*VpcConfigResponse, error) {
	out := new(VpcConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.VpcConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcConfigServiceClient) GetAll(ctx context.Context, in *VpcConfigStreamRequest, opts ...grpc.CallOption) (VpcConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &VpcConfigService_ServiceDesc.Streams[0], "/arista.clouddeploy.v1.VpcConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &vpcConfigServiceGetAllClient{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 VpcConfigService_GetAllClient interface {
	Recv() (*VpcConfigStreamResponse, error)
	grpc.ClientStream
}

type vpcConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *vpcConfigServiceClient) Subscribe(ctx context.Context, in *VpcConfigStreamRequest, opts ...grpc.CallOption) (VpcConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &VpcConfigService_ServiceDesc.Streams[1], "/arista.clouddeploy.v1.VpcConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &vpcConfigServiceSubscribeClient{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 VpcConfigService_SubscribeClient interface {
	Recv() (*VpcConfigStreamResponse, error)
	grpc.ClientStream
}

type vpcConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *vpcConfigServiceClient) Set(ctx context.Context, in *VpcConfigSetRequest, opts ...grpc.CallOption) (*VpcConfigSetResponse, error) {
	out := new(VpcConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.VpcConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcConfigServiceClient) SetSome(ctx context.Context, in *VpcConfigSetSomeRequest, opts ...grpc.CallOption) (VpcConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &VpcConfigService_ServiceDesc.Streams[2], "/arista.clouddeploy.v1.VpcConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &vpcConfigServiceSetSomeClient{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 VpcConfigService_SetSomeClient interface {
	Recv() (*VpcConfigSetSomeResponse, error)
	grpc.ClientStream
}

type vpcConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *vpcConfigServiceClient) Delete(ctx context.Context, in *VpcConfigDeleteRequest, opts ...grpc.CallOption) (*VpcConfigDeleteResponse, error) {
	out := new(VpcConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.clouddeploy.v1.VpcConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vpcConfigServiceClient) DeleteAll(ctx context.Context, in *VpcConfigDeleteAllRequest, opts ...grpc.CallOption) (VpcConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &VpcConfigService_ServiceDesc.Streams[3], "/arista.clouddeploy.v1.VpcConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &vpcConfigServiceDeleteAllClient{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 VpcConfigService_DeleteAllClient interface {
	Recv() (*VpcConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type vpcConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// VpcConfigServiceServer is the server API for VpcConfigService service.
// All implementations must embed UnimplementedVpcConfigServiceServer
// for forward compatibility
type VpcConfigServiceServer interface {
	GetOne(context.Context, *VpcConfigRequest) (*VpcConfigResponse, error)
	GetAll(*VpcConfigStreamRequest, VpcConfigService_GetAllServer) error
	Subscribe(*VpcConfigStreamRequest, VpcConfigService_SubscribeServer) error
	Set(context.Context, *VpcConfigSetRequest) (*VpcConfigSetResponse, error)
	SetSome(*VpcConfigSetSomeRequest, VpcConfigService_SetSomeServer) error
	Delete(context.Context, *VpcConfigDeleteRequest) (*VpcConfigDeleteResponse, error)
	DeleteAll(*VpcConfigDeleteAllRequest, VpcConfigService_DeleteAllServer) error
	mustEmbedUnimplementedVpcConfigServiceServer()
}

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

func (UnimplementedVpcConfigServiceServer) GetOne(context.Context, *VpcConfigRequest) (*VpcConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedVpcConfigServiceServer) GetAll(*VpcConfigStreamRequest, VpcConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedVpcConfigServiceServer) Subscribe(*VpcConfigStreamRequest, VpcConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedVpcConfigServiceServer) Set(context.Context, *VpcConfigSetRequest) (*VpcConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedVpcConfigServiceServer) SetSome(*VpcConfigSetSomeRequest, VpcConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedVpcConfigServiceServer) Delete(context.Context, *VpcConfigDeleteRequest) (*VpcConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedVpcConfigServiceServer) DeleteAll(*VpcConfigDeleteAllRequest, VpcConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedVpcConfigServiceServer) mustEmbedUnimplementedVpcConfigServiceServer() {}

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

func RegisterVpcConfigServiceServer(s grpc.ServiceRegistrar, srv VpcConfigServiceServer) {
	s.RegisterService(&VpcConfigService_ServiceDesc, srv)
}

func _VpcConfigService_GetOne_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VpcConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcConfigServiceServer).GetOne(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.VpcConfigService/GetOne",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcConfigServiceServer).GetOne(ctx, req.(*VpcConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VpcConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VpcConfigServiceServer).GetAll(m, &vpcConfigServiceGetAllServer{stream})
}

type VpcConfigService_GetAllServer interface {
	Send(*VpcConfigStreamResponse) error
	grpc.ServerStream
}

type vpcConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *vpcConfigServiceGetAllServer) Send(m *VpcConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VpcConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VpcConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VpcConfigServiceServer).Subscribe(m, &vpcConfigServiceSubscribeServer{stream})
}

type VpcConfigService_SubscribeServer interface {
	Send(*VpcConfigStreamResponse) error
	grpc.ServerStream
}

type vpcConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *vpcConfigServiceSubscribeServer) Send(m *VpcConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VpcConfigService_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VpcConfigSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcConfigServiceServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.VpcConfigService/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcConfigServiceServer).Set(ctx, req.(*VpcConfigSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VpcConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VpcConfigServiceServer).SetSome(m, &vpcConfigServiceSetSomeServer{stream})
}

type VpcConfigService_SetSomeServer interface {
	Send(*VpcConfigSetSomeResponse) error
	grpc.ServerStream
}

type vpcConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *vpcConfigServiceSetSomeServer) Send(m *VpcConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VpcConfigService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VpcConfigDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VpcConfigServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.clouddeploy.v1.VpcConfigService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VpcConfigServiceServer).Delete(ctx, req.(*VpcConfigDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VpcConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VpcConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VpcConfigServiceServer).DeleteAll(m, &vpcConfigServiceDeleteAllServer{stream})
}

type VpcConfigService_DeleteAllServer interface {
	Send(*VpcConfigDeleteAllResponse) error
	grpc.ServerStream
}

type vpcConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *vpcConfigServiceDeleteAllServer) Send(m *VpcConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// VpcConfigService_ServiceDesc is the grpc.ServiceDesc for VpcConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var VpcConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.clouddeploy.v1.VpcConfigService",
	HandlerType: (*VpcConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _VpcConfigService_GetOne_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _VpcConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _VpcConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAll",
			Handler:       _VpcConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _VpcConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _VpcConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _VpcConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/clouddeploy.v1/services.gen.proto",
}