services.gen_grpc.pb.go

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

package studio

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

// AssignedTagsServiceClient is the client API for AssignedTagsService 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 AssignedTagsServiceClient interface {
	GetOne(ctx context.Context, in *AssignedTagsRequest, opts ...grpc.CallOption) (*AssignedTagsResponse, error)
	GetSome(ctx context.Context, in *AssignedTagsSomeRequest, opts ...grpc.CallOption) (AssignedTagsService_GetSomeClient, error)
	GetAll(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_SubscribeMetaClient, error)
}

type assignedTagsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAssignedTagsServiceClient(cc grpc.ClientConnInterface) AssignedTagsServiceClient {
	return &assignedTagsServiceClient{cc}
}

func (c *assignedTagsServiceClient) GetOne(ctx context.Context, in *AssignedTagsRequest, opts ...grpc.CallOption) (*AssignedTagsResponse, error) {
	out := new(AssignedTagsResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsServiceClient) GetSome(ctx context.Context, in *AssignedTagsSomeRequest, opts ...grpc.CallOption) (AssignedTagsService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsService_ServiceDesc.Streams[0], "/arista.studio.v1.AssignedTagsService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsServiceGetSomeClient{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 AssignedTagsService_GetSomeClient interface {
	Recv() (*AssignedTagsSomeResponse, error)
	grpc.ClientStream
}

type assignedTagsServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsServiceClient) GetAll(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsService_ServiceDesc.Streams[1], "/arista.studio.v1.AssignedTagsService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsServiceGetAllClient{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 AssignedTagsService_GetAllClient interface {
	Recv() (*AssignedTagsStreamResponse, error)
	grpc.ClientStream
}

type assignedTagsServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsServiceClient) Subscribe(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsService_ServiceDesc.Streams[2], "/arista.studio.v1.AssignedTagsService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsServiceSubscribeClient{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 AssignedTagsService_SubscribeClient interface {
	Recv() (*AssignedTagsStreamResponse, error)
	grpc.ClientStream
}

type assignedTagsServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsServiceClient) GetMeta(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsServiceClient) SubscribeMeta(ctx context.Context, in *AssignedTagsStreamRequest, opts ...grpc.CallOption) (AssignedTagsService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsService_ServiceDesc.Streams[3], "/arista.studio.v1.AssignedTagsService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsServiceSubscribeMetaClient{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 AssignedTagsService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type assignedTagsServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// AssignedTagsServiceServer is the server API for AssignedTagsService service.
// All implementations must embed UnimplementedAssignedTagsServiceServer
// for forward compatibility
type AssignedTagsServiceServer interface {
	GetOne(context.Context, *AssignedTagsRequest) (*AssignedTagsResponse, error)
	GetSome(*AssignedTagsSomeRequest, AssignedTagsService_GetSomeServer) error
	GetAll(*AssignedTagsStreamRequest, AssignedTagsService_GetAllServer) error
	Subscribe(*AssignedTagsStreamRequest, AssignedTagsService_SubscribeServer) error
	GetMeta(context.Context, *AssignedTagsStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*AssignedTagsStreamRequest, AssignedTagsService_SubscribeMetaServer) error
	mustEmbedUnimplementedAssignedTagsServiceServer()
}

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

func (UnimplementedAssignedTagsServiceServer) GetOne(context.Context, *AssignedTagsRequest) (*AssignedTagsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAssignedTagsServiceServer) GetSome(*AssignedTagsSomeRequest, AssignedTagsService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedAssignedTagsServiceServer) GetAll(*AssignedTagsStreamRequest, AssignedTagsService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAssignedTagsServiceServer) Subscribe(*AssignedTagsStreamRequest, AssignedTagsService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAssignedTagsServiceServer) GetMeta(context.Context, *AssignedTagsStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedAssignedTagsServiceServer) SubscribeMeta(*AssignedTagsStreamRequest, AssignedTagsService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAssignedTagsServiceServer) mustEmbedUnimplementedAssignedTagsServiceServer() {}

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

func RegisterAssignedTagsServiceServer(s grpc.ServiceRegistrar, srv AssignedTagsServiceServer) {
	s.RegisterService(&AssignedTagsService_ServiceDesc, srv)
}

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

func _AssignedTagsService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsServiceServer).GetSome(m, &assignedTagsServiceGetSomeServer{stream})
}

type AssignedTagsService_GetSomeServer interface {
	Send(*AssignedTagsSomeResponse) error
	grpc.ServerStream
}

type assignedTagsServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsServiceGetSomeServer) Send(m *AssignedTagsSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsServiceServer).GetAll(m, &assignedTagsServiceGetAllServer{stream})
}

type AssignedTagsService_GetAllServer interface {
	Send(*AssignedTagsStreamResponse) error
	grpc.ServerStream
}

type assignedTagsServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *assignedTagsServiceGetAllServer) Send(m *AssignedTagsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsServiceServer).Subscribe(m, &assignedTagsServiceSubscribeServer{stream})
}

type AssignedTagsService_SubscribeServer interface {
	Send(*AssignedTagsStreamResponse) error
	grpc.ServerStream
}

type assignedTagsServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsServiceSubscribeServer) Send(m *AssignedTagsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AssignedTagsStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AssignedTagsServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.AssignedTagsService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AssignedTagsServiceServer).GetMeta(ctx, req.(*AssignedTagsStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AssignedTagsService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsServiceServer).SubscribeMeta(m, &assignedTagsServiceSubscribeMetaServer{stream})
}

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

type assignedTagsServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// AssignedTagsService_ServiceDesc is the grpc.ServiceDesc for AssignedTagsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AssignedTagsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.AssignedTagsService",
	HandlerType: (*AssignedTagsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AssignedTagsService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _AssignedTagsService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _AssignedTagsService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _AssignedTagsService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AssignedTagsService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AssignedTagsService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// AssignedTagsConfigServiceClient is the client API for AssignedTagsConfigService 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 AssignedTagsConfigServiceClient interface {
	GetOne(ctx context.Context, in *AssignedTagsConfigRequest, opts ...grpc.CallOption) (*AssignedTagsConfigResponse, error)
	GetSome(ctx context.Context, in *AssignedTagsConfigSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *AssignedTagsConfigSetRequest, opts ...grpc.CallOption) (*AssignedTagsConfigSetResponse, error)
	SetSome(ctx context.Context, in *AssignedTagsConfigSetSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *AssignedTagsConfigDeleteRequest, opts ...grpc.CallOption) (*AssignedTagsConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *AssignedTagsConfigDeleteSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *AssignedTagsConfigDeleteAllRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_DeleteAllClient, error)
}

type assignedTagsConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAssignedTagsConfigServiceClient(cc grpc.ClientConnInterface) AssignedTagsConfigServiceClient {
	return &assignedTagsConfigServiceClient{cc}
}

func (c *assignedTagsConfigServiceClient) GetOne(ctx context.Context, in *AssignedTagsConfigRequest, opts ...grpc.CallOption) (*AssignedTagsConfigResponse, error) {
	out := new(AssignedTagsConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsConfigServiceClient) GetSome(ctx context.Context, in *AssignedTagsConfigSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[0], "/arista.studio.v1.AssignedTagsConfigService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceGetSomeClient{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 AssignedTagsConfigService_GetSomeClient interface {
	Recv() (*AssignedTagsConfigSomeResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) GetAll(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[1], "/arista.studio.v1.AssignedTagsConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceGetAllClient{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 AssignedTagsConfigService_GetAllClient interface {
	Recv() (*AssignedTagsConfigStreamResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) Subscribe(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[2], "/arista.studio.v1.AssignedTagsConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceSubscribeClient{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 AssignedTagsConfigService_SubscribeClient interface {
	Recv() (*AssignedTagsConfigStreamResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) GetMeta(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsConfigService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsConfigServiceClient) SubscribeMeta(ctx context.Context, in *AssignedTagsConfigStreamRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[3], "/arista.studio.v1.AssignedTagsConfigService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceSubscribeMetaClient{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 AssignedTagsConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) Set(ctx context.Context, in *AssignedTagsConfigSetRequest, opts ...grpc.CallOption) (*AssignedTagsConfigSetResponse, error) {
	out := new(AssignedTagsConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsConfigServiceClient) SetSome(ctx context.Context, in *AssignedTagsConfigSetSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[4], "/arista.studio.v1.AssignedTagsConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceSetSomeClient{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 AssignedTagsConfigService_SetSomeClient interface {
	Recv() (*AssignedTagsConfigSetSomeResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) Delete(ctx context.Context, in *AssignedTagsConfigDeleteRequest, opts ...grpc.CallOption) (*AssignedTagsConfigDeleteResponse, error) {
	out := new(AssignedTagsConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AssignedTagsConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *assignedTagsConfigServiceClient) DeleteSome(ctx context.Context, in *AssignedTagsConfigDeleteSomeRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[5], "/arista.studio.v1.AssignedTagsConfigService/DeleteSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceDeleteSomeClient{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 AssignedTagsConfigService_DeleteSomeClient interface {
	Recv() (*AssignedTagsConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *assignedTagsConfigServiceClient) DeleteAll(ctx context.Context, in *AssignedTagsConfigDeleteAllRequest, opts ...grpc.CallOption) (AssignedTagsConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AssignedTagsConfigService_ServiceDesc.Streams[6], "/arista.studio.v1.AssignedTagsConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &assignedTagsConfigServiceDeleteAllClient{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 AssignedTagsConfigService_DeleteAllClient interface {
	Recv() (*AssignedTagsConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type assignedTagsConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// AssignedTagsConfigServiceServer is the server API for AssignedTagsConfigService service.
// All implementations must embed UnimplementedAssignedTagsConfigServiceServer
// for forward compatibility
type AssignedTagsConfigServiceServer interface {
	GetOne(context.Context, *AssignedTagsConfigRequest) (*AssignedTagsConfigResponse, error)
	GetSome(*AssignedTagsConfigSomeRequest, AssignedTagsConfigService_GetSomeServer) error
	GetAll(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_GetAllServer) error
	Subscribe(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_SubscribeServer) error
	GetMeta(context.Context, *AssignedTagsConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_SubscribeMetaServer) error
	Set(context.Context, *AssignedTagsConfigSetRequest) (*AssignedTagsConfigSetResponse, error)
	SetSome(*AssignedTagsConfigSetSomeRequest, AssignedTagsConfigService_SetSomeServer) error
	Delete(context.Context, *AssignedTagsConfigDeleteRequest) (*AssignedTagsConfigDeleteResponse, error)
	DeleteSome(*AssignedTagsConfigDeleteSomeRequest, AssignedTagsConfigService_DeleteSomeServer) error
	DeleteAll(*AssignedTagsConfigDeleteAllRequest, AssignedTagsConfigService_DeleteAllServer) error
	mustEmbedUnimplementedAssignedTagsConfigServiceServer()
}

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

func (UnimplementedAssignedTagsConfigServiceServer) GetOne(context.Context, *AssignedTagsConfigRequest) (*AssignedTagsConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) GetSome(*AssignedTagsConfigSomeRequest, AssignedTagsConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) GetAll(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) Subscribe(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) GetMeta(context.Context, *AssignedTagsConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) SubscribeMeta(*AssignedTagsConfigStreamRequest, AssignedTagsConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) Set(context.Context, *AssignedTagsConfigSetRequest) (*AssignedTagsConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) SetSome(*AssignedTagsConfigSetSomeRequest, AssignedTagsConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) Delete(context.Context, *AssignedTagsConfigDeleteRequest) (*AssignedTagsConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) DeleteSome(*AssignedTagsConfigDeleteSomeRequest, AssignedTagsConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) DeleteAll(*AssignedTagsConfigDeleteAllRequest, AssignedTagsConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedAssignedTagsConfigServiceServer) mustEmbedUnimplementedAssignedTagsConfigServiceServer() {
}

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

func RegisterAssignedTagsConfigServiceServer(s grpc.ServiceRegistrar, srv AssignedTagsConfigServiceServer) {
	s.RegisterService(&AssignedTagsConfigService_ServiceDesc, srv)
}

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

func _AssignedTagsConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).GetSome(m, &assignedTagsConfigServiceGetSomeServer{stream})
}

type AssignedTagsConfigService_GetSomeServer interface {
	Send(*AssignedTagsConfigSomeResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceGetSomeServer) Send(m *AssignedTagsConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).GetAll(m, &assignedTagsConfigServiceGetAllServer{stream})
}

type AssignedTagsConfigService_GetAllServer interface {
	Send(*AssignedTagsConfigStreamResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceGetAllServer) Send(m *AssignedTagsConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).Subscribe(m, &assignedTagsConfigServiceSubscribeServer{stream})
}

type AssignedTagsConfigService_SubscribeServer interface {
	Send(*AssignedTagsConfigStreamResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceSubscribeServer) Send(m *AssignedTagsConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsConfigService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AssignedTagsConfigStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AssignedTagsConfigServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.AssignedTagsConfigService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AssignedTagsConfigServiceServer).GetMeta(ctx, req.(*AssignedTagsConfigStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AssignedTagsConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).SubscribeMeta(m, &assignedTagsConfigServiceSubscribeMetaServer{stream})
}

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

type assignedTagsConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _AssignedTagsConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).SetSome(m, &assignedTagsConfigServiceSetSomeServer{stream})
}

type AssignedTagsConfigService_SetSomeServer interface {
	Send(*AssignedTagsConfigSetSomeResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceSetSomeServer) Send(m *AssignedTagsConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _AssignedTagsConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).DeleteSome(m, &assignedTagsConfigServiceDeleteSomeServer{stream})
}

type AssignedTagsConfigService_DeleteSomeServer interface {
	Send(*AssignedTagsConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceDeleteSomeServer) Send(m *AssignedTagsConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AssignedTagsConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AssignedTagsConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AssignedTagsConfigServiceServer).DeleteAll(m, &assignedTagsConfigServiceDeleteAllServer{stream})
}

type AssignedTagsConfigService_DeleteAllServer interface {
	Send(*AssignedTagsConfigDeleteAllResponse) error
	grpc.ServerStream
}

type assignedTagsConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *assignedTagsConfigServiceDeleteAllServer) Send(m *AssignedTagsConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AssignedTagsConfigService_ServiceDesc is the grpc.ServiceDesc for AssignedTagsConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AssignedTagsConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.AssignedTagsConfigService",
	HandlerType: (*AssignedTagsConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AssignedTagsConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _AssignedTagsConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _AssignedTagsConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _AssignedTagsConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _AssignedTagsConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _AssignedTagsConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AssignedTagsConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AssignedTagsConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _AssignedTagsConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _AssignedTagsConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _AssignedTagsConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// AutofillActionServiceClient is the client API for AutofillActionService 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 AutofillActionServiceClient interface {
	GetOne(ctx context.Context, in *AutofillActionRequest, opts ...grpc.CallOption) (*AutofillActionResponse, error)
	GetSome(ctx context.Context, in *AutofillActionSomeRequest, opts ...grpc.CallOption) (AutofillActionService_GetSomeClient, error)
	GetAll(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_SubscribeMetaClient, error)
}

type autofillActionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAutofillActionServiceClient(cc grpc.ClientConnInterface) AutofillActionServiceClient {
	return &autofillActionServiceClient{cc}
}

func (c *autofillActionServiceClient) GetOne(ctx context.Context, in *AutofillActionRequest, opts ...grpc.CallOption) (*AutofillActionResponse, error) {
	out := new(AutofillActionResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionServiceClient) GetSome(ctx context.Context, in *AutofillActionSomeRequest, opts ...grpc.CallOption) (AutofillActionService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionService_ServiceDesc.Streams[0], "/arista.studio.v1.AutofillActionService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionServiceGetSomeClient{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 AutofillActionService_GetSomeClient interface {
	Recv() (*AutofillActionSomeResponse, error)
	grpc.ClientStream
}

type autofillActionServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionServiceClient) GetAll(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionService_ServiceDesc.Streams[1], "/arista.studio.v1.AutofillActionService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionServiceGetAllClient{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 AutofillActionService_GetAllClient interface {
	Recv() (*AutofillActionStreamResponse, error)
	grpc.ClientStream
}

type autofillActionServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionServiceClient) Subscribe(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionService_ServiceDesc.Streams[2], "/arista.studio.v1.AutofillActionService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionServiceSubscribeClient{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 AutofillActionService_SubscribeClient interface {
	Recv() (*AutofillActionStreamResponse, error)
	grpc.ClientStream
}

type autofillActionServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionServiceClient) GetMeta(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionServiceClient) SubscribeMeta(ctx context.Context, in *AutofillActionStreamRequest, opts ...grpc.CallOption) (AutofillActionService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionService_ServiceDesc.Streams[3], "/arista.studio.v1.AutofillActionService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionServiceSubscribeMetaClient{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 AutofillActionService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type autofillActionServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// AutofillActionServiceServer is the server API for AutofillActionService service.
// All implementations must embed UnimplementedAutofillActionServiceServer
// for forward compatibility
type AutofillActionServiceServer interface {
	GetOne(context.Context, *AutofillActionRequest) (*AutofillActionResponse, error)
	GetSome(*AutofillActionSomeRequest, AutofillActionService_GetSomeServer) error
	GetAll(*AutofillActionStreamRequest, AutofillActionService_GetAllServer) error
	Subscribe(*AutofillActionStreamRequest, AutofillActionService_SubscribeServer) error
	GetMeta(context.Context, *AutofillActionStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*AutofillActionStreamRequest, AutofillActionService_SubscribeMetaServer) error
	mustEmbedUnimplementedAutofillActionServiceServer()
}

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

func (UnimplementedAutofillActionServiceServer) GetOne(context.Context, *AutofillActionRequest) (*AutofillActionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAutofillActionServiceServer) GetSome(*AutofillActionSomeRequest, AutofillActionService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedAutofillActionServiceServer) GetAll(*AutofillActionStreamRequest, AutofillActionService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAutofillActionServiceServer) Subscribe(*AutofillActionStreamRequest, AutofillActionService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAutofillActionServiceServer) GetMeta(context.Context, *AutofillActionStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedAutofillActionServiceServer) SubscribeMeta(*AutofillActionStreamRequest, AutofillActionService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAutofillActionServiceServer) mustEmbedUnimplementedAutofillActionServiceServer() {}

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

func RegisterAutofillActionServiceServer(s grpc.ServiceRegistrar, srv AutofillActionServiceServer) {
	s.RegisterService(&AutofillActionService_ServiceDesc, srv)
}

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

func _AutofillActionService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionServiceServer).GetSome(m, &autofillActionServiceGetSomeServer{stream})
}

type AutofillActionService_GetSomeServer interface {
	Send(*AutofillActionSomeResponse) error
	grpc.ServerStream
}

type autofillActionServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *autofillActionServiceGetSomeServer) Send(m *AutofillActionSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionServiceServer).GetAll(m, &autofillActionServiceGetAllServer{stream})
}

type AutofillActionService_GetAllServer interface {
	Send(*AutofillActionStreamResponse) error
	grpc.ServerStream
}

type autofillActionServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *autofillActionServiceGetAllServer) Send(m *AutofillActionStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionServiceServer).Subscribe(m, &autofillActionServiceSubscribeServer{stream})
}

type AutofillActionService_SubscribeServer interface {
	Send(*AutofillActionStreamResponse) error
	grpc.ServerStream
}

type autofillActionServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *autofillActionServiceSubscribeServer) Send(m *AutofillActionStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AutofillActionStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AutofillActionServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.AutofillActionService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AutofillActionServiceServer).GetMeta(ctx, req.(*AutofillActionStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AutofillActionService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionServiceServer).SubscribeMeta(m, &autofillActionServiceSubscribeMetaServer{stream})
}

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

type autofillActionServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// AutofillActionService_ServiceDesc is the grpc.ServiceDesc for AutofillActionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AutofillActionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.AutofillActionService",
	HandlerType: (*AutofillActionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AutofillActionService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _AutofillActionService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _AutofillActionService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _AutofillActionService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AutofillActionService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AutofillActionService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// AutofillActionConfigServiceClient is the client API for AutofillActionConfigService 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 AutofillActionConfigServiceClient interface {
	GetOne(ctx context.Context, in *AutofillActionConfigRequest, opts ...grpc.CallOption) (*AutofillActionConfigResponse, error)
	GetSome(ctx context.Context, in *AutofillActionConfigSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *AutofillActionConfigSetRequest, opts ...grpc.CallOption) (*AutofillActionConfigSetResponse, error)
	SetSome(ctx context.Context, in *AutofillActionConfigSetSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *AutofillActionConfigDeleteRequest, opts ...grpc.CallOption) (*AutofillActionConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *AutofillActionConfigDeleteSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *AutofillActionConfigDeleteAllRequest, opts ...grpc.CallOption) (AutofillActionConfigService_DeleteAllClient, error)
}

type autofillActionConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAutofillActionConfigServiceClient(cc grpc.ClientConnInterface) AutofillActionConfigServiceClient {
	return &autofillActionConfigServiceClient{cc}
}

func (c *autofillActionConfigServiceClient) GetOne(ctx context.Context, in *AutofillActionConfigRequest, opts ...grpc.CallOption) (*AutofillActionConfigResponse, error) {
	out := new(AutofillActionConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionConfigServiceClient) GetSome(ctx context.Context, in *AutofillActionConfigSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[0], "/arista.studio.v1.AutofillActionConfigService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceGetSomeClient{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 AutofillActionConfigService_GetSomeClient interface {
	Recv() (*AutofillActionConfigSomeResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) GetAll(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[1], "/arista.studio.v1.AutofillActionConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceGetAllClient{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 AutofillActionConfigService_GetAllClient interface {
	Recv() (*AutofillActionConfigStreamResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) Subscribe(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[2], "/arista.studio.v1.AutofillActionConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceSubscribeClient{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 AutofillActionConfigService_SubscribeClient interface {
	Recv() (*AutofillActionConfigStreamResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) GetMeta(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionConfigService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionConfigServiceClient) SubscribeMeta(ctx context.Context, in *AutofillActionConfigStreamRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[3], "/arista.studio.v1.AutofillActionConfigService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceSubscribeMetaClient{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 AutofillActionConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) Set(ctx context.Context, in *AutofillActionConfigSetRequest, opts ...grpc.CallOption) (*AutofillActionConfigSetResponse, error) {
	out := new(AutofillActionConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionConfigServiceClient) SetSome(ctx context.Context, in *AutofillActionConfigSetSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[4], "/arista.studio.v1.AutofillActionConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceSetSomeClient{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 AutofillActionConfigService_SetSomeClient interface {
	Recv() (*AutofillActionConfigSetSomeResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) Delete(ctx context.Context, in *AutofillActionConfigDeleteRequest, opts ...grpc.CallOption) (*AutofillActionConfigDeleteResponse, error) {
	out := new(AutofillActionConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.AutofillActionConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *autofillActionConfigServiceClient) DeleteSome(ctx context.Context, in *AutofillActionConfigDeleteSomeRequest, opts ...grpc.CallOption) (AutofillActionConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[5], "/arista.studio.v1.AutofillActionConfigService/DeleteSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceDeleteSomeClient{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 AutofillActionConfigService_DeleteSomeClient interface {
	Recv() (*AutofillActionConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *autofillActionConfigServiceClient) DeleteAll(ctx context.Context, in *AutofillActionConfigDeleteAllRequest, opts ...grpc.CallOption) (AutofillActionConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &AutofillActionConfigService_ServiceDesc.Streams[6], "/arista.studio.v1.AutofillActionConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &autofillActionConfigServiceDeleteAllClient{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 AutofillActionConfigService_DeleteAllClient interface {
	Recv() (*AutofillActionConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type autofillActionConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// AutofillActionConfigServiceServer is the server API for AutofillActionConfigService service.
// All implementations must embed UnimplementedAutofillActionConfigServiceServer
// for forward compatibility
type AutofillActionConfigServiceServer interface {
	GetOne(context.Context, *AutofillActionConfigRequest) (*AutofillActionConfigResponse, error)
	GetSome(*AutofillActionConfigSomeRequest, AutofillActionConfigService_GetSomeServer) error
	GetAll(*AutofillActionConfigStreamRequest, AutofillActionConfigService_GetAllServer) error
	Subscribe(*AutofillActionConfigStreamRequest, AutofillActionConfigService_SubscribeServer) error
	GetMeta(context.Context, *AutofillActionConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*AutofillActionConfigStreamRequest, AutofillActionConfigService_SubscribeMetaServer) error
	Set(context.Context, *AutofillActionConfigSetRequest) (*AutofillActionConfigSetResponse, error)
	SetSome(*AutofillActionConfigSetSomeRequest, AutofillActionConfigService_SetSomeServer) error
	Delete(context.Context, *AutofillActionConfigDeleteRequest) (*AutofillActionConfigDeleteResponse, error)
	DeleteSome(*AutofillActionConfigDeleteSomeRequest, AutofillActionConfigService_DeleteSomeServer) error
	DeleteAll(*AutofillActionConfigDeleteAllRequest, AutofillActionConfigService_DeleteAllServer) error
	mustEmbedUnimplementedAutofillActionConfigServiceServer()
}

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

func (UnimplementedAutofillActionConfigServiceServer) GetOne(context.Context, *AutofillActionConfigRequest) (*AutofillActionConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) GetSome(*AutofillActionConfigSomeRequest, AutofillActionConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) GetAll(*AutofillActionConfigStreamRequest, AutofillActionConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) Subscribe(*AutofillActionConfigStreamRequest, AutofillActionConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) GetMeta(context.Context, *AutofillActionConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) SubscribeMeta(*AutofillActionConfigStreamRequest, AutofillActionConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) Set(context.Context, *AutofillActionConfigSetRequest) (*AutofillActionConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) SetSome(*AutofillActionConfigSetSomeRequest, AutofillActionConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) Delete(context.Context, *AutofillActionConfigDeleteRequest) (*AutofillActionConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) DeleteSome(*AutofillActionConfigDeleteSomeRequest, AutofillActionConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) DeleteAll(*AutofillActionConfigDeleteAllRequest, AutofillActionConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedAutofillActionConfigServiceServer) mustEmbedUnimplementedAutofillActionConfigServiceServer() {
}

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

func RegisterAutofillActionConfigServiceServer(s grpc.ServiceRegistrar, srv AutofillActionConfigServiceServer) {
	s.RegisterService(&AutofillActionConfigService_ServiceDesc, srv)
}

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

func _AutofillActionConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).GetSome(m, &autofillActionConfigServiceGetSomeServer{stream})
}

type AutofillActionConfigService_GetSomeServer interface {
	Send(*AutofillActionConfigSomeResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceGetSomeServer) Send(m *AutofillActionConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).GetAll(m, &autofillActionConfigServiceGetAllServer{stream})
}

type AutofillActionConfigService_GetAllServer interface {
	Send(*AutofillActionConfigStreamResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceGetAllServer) Send(m *AutofillActionConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).Subscribe(m, &autofillActionConfigServiceSubscribeServer{stream})
}

type AutofillActionConfigService_SubscribeServer interface {
	Send(*AutofillActionConfigStreamResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceSubscribeServer) Send(m *AutofillActionConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionConfigService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AutofillActionConfigStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AutofillActionConfigServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.AutofillActionConfigService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AutofillActionConfigServiceServer).GetMeta(ctx, req.(*AutofillActionConfigStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AutofillActionConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).SubscribeMeta(m, &autofillActionConfigServiceSubscribeMetaServer{stream})
}

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

type autofillActionConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _AutofillActionConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).SetSome(m, &autofillActionConfigServiceSetSomeServer{stream})
}

type AutofillActionConfigService_SetSomeServer interface {
	Send(*AutofillActionConfigSetSomeResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceSetSomeServer) Send(m *AutofillActionConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _AutofillActionConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).DeleteSome(m, &autofillActionConfigServiceDeleteSomeServer{stream})
}

type AutofillActionConfigService_DeleteSomeServer interface {
	Send(*AutofillActionConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceDeleteSomeServer) Send(m *AutofillActionConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AutofillActionConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AutofillActionConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AutofillActionConfigServiceServer).DeleteAll(m, &autofillActionConfigServiceDeleteAllServer{stream})
}

type AutofillActionConfigService_DeleteAllServer interface {
	Send(*AutofillActionConfigDeleteAllResponse) error
	grpc.ServerStream
}

type autofillActionConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *autofillActionConfigServiceDeleteAllServer) Send(m *AutofillActionConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AutofillActionConfigService_ServiceDesc is the grpc.ServiceDesc for AutofillActionConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AutofillActionConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.AutofillActionConfigService",
	HandlerType: (*AutofillActionConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _AutofillActionConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _AutofillActionConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _AutofillActionConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _AutofillActionConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _AutofillActionConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _AutofillActionConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _AutofillActionConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _AutofillActionConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _AutofillActionConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _AutofillActionConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _AutofillActionConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// InputsServiceClient is the client API for InputsService 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 InputsServiceClient interface {
	GetOne(ctx context.Context, in *InputsRequest, opts ...grpc.CallOption) (*InputsResponse, error)
	GetSome(ctx context.Context, in *InputsSomeRequest, opts ...grpc.CallOption) (InputsService_GetSomeClient, error)
	GetAll(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_GetAllClient, error)
	Subscribe(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_SubscribeMetaClient, error)
}

type inputsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInputsServiceClient(cc grpc.ClientConnInterface) InputsServiceClient {
	return &inputsServiceClient{cc}
}

func (c *inputsServiceClient) GetOne(ctx context.Context, in *InputsRequest, opts ...grpc.CallOption) (*InputsResponse, error) {
	out := new(InputsResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsServiceClient) GetSome(ctx context.Context, in *InputsSomeRequest, opts ...grpc.CallOption) (InputsService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsService_ServiceDesc.Streams[0], "/arista.studio.v1.InputsService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsServiceGetSomeClient{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 InputsService_GetSomeClient interface {
	Recv() (*InputsSomeResponse, error)
	grpc.ClientStream
}

type inputsServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *inputsServiceClient) GetAll(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsService_ServiceDesc.Streams[1], "/arista.studio.v1.InputsService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsServiceGetAllClient{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 InputsService_GetAllClient interface {
	Recv() (*InputsStreamResponse, error)
	grpc.ClientStream
}

type inputsServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *inputsServiceClient) Subscribe(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsService_ServiceDesc.Streams[2], "/arista.studio.v1.InputsService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsServiceSubscribeClient{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 InputsService_SubscribeClient interface {
	Recv() (*InputsStreamResponse, error)
	grpc.ClientStream
}

type inputsServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *inputsServiceClient) GetMeta(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsServiceClient) SubscribeMeta(ctx context.Context, in *InputsStreamRequest, opts ...grpc.CallOption) (InputsService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsService_ServiceDesc.Streams[3], "/arista.studio.v1.InputsService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsServiceSubscribeMetaClient{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 InputsService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type inputsServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// InputsServiceServer is the server API for InputsService service.
// All implementations must embed UnimplementedInputsServiceServer
// for forward compatibility
type InputsServiceServer interface {
	GetOne(context.Context, *InputsRequest) (*InputsResponse, error)
	GetSome(*InputsSomeRequest, InputsService_GetSomeServer) error
	GetAll(*InputsStreamRequest, InputsService_GetAllServer) error
	Subscribe(*InputsStreamRequest, InputsService_SubscribeServer) error
	GetMeta(context.Context, *InputsStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*InputsStreamRequest, InputsService_SubscribeMetaServer) error
	mustEmbedUnimplementedInputsServiceServer()
}

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

func (UnimplementedInputsServiceServer) GetOne(context.Context, *InputsRequest) (*InputsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedInputsServiceServer) GetSome(*InputsSomeRequest, InputsService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedInputsServiceServer) GetAll(*InputsStreamRequest, InputsService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedInputsServiceServer) Subscribe(*InputsStreamRequest, InputsService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedInputsServiceServer) GetMeta(context.Context, *InputsStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedInputsServiceServer) SubscribeMeta(*InputsStreamRequest, InputsService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedInputsServiceServer) mustEmbedUnimplementedInputsServiceServer() {}

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

func RegisterInputsServiceServer(s grpc.ServiceRegistrar, srv InputsServiceServer) {
	s.RegisterService(&InputsService_ServiceDesc, srv)
}

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

func _InputsService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsServiceServer).GetSome(m, &inputsServiceGetSomeServer{stream})
}

type InputsService_GetSomeServer interface {
	Send(*InputsSomeResponse) error
	grpc.ServerStream
}

type inputsServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *inputsServiceGetSomeServer) Send(m *InputsSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsServiceServer).GetAll(m, &inputsServiceGetAllServer{stream})
}

type InputsService_GetAllServer interface {
	Send(*InputsStreamResponse) error
	grpc.ServerStream
}

type inputsServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *inputsServiceGetAllServer) Send(m *InputsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsServiceServer).Subscribe(m, &inputsServiceSubscribeServer{stream})
}

type InputsService_SubscribeServer interface {
	Send(*InputsStreamResponse) error
	grpc.ServerStream
}

type inputsServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *inputsServiceSubscribeServer) Send(m *InputsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InputsStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InputsServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.InputsService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InputsServiceServer).GetMeta(ctx, req.(*InputsStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InputsService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsServiceServer).SubscribeMeta(m, &inputsServiceSubscribeMetaServer{stream})
}

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

type inputsServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// InputsService_ServiceDesc is the grpc.ServiceDesc for InputsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InputsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.InputsService",
	HandlerType: (*InputsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _InputsService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _InputsService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _InputsService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _InputsService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _InputsService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _InputsService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// InputsConfigServiceClient is the client API for InputsConfigService 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 InputsConfigServiceClient interface {
	GetOne(ctx context.Context, in *InputsConfigRequest, opts ...grpc.CallOption) (*InputsConfigResponse, error)
	GetSome(ctx context.Context, in *InputsConfigSomeRequest, opts ...grpc.CallOption) (InputsConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *InputsConfigSetRequest, opts ...grpc.CallOption) (*InputsConfigSetResponse, error)
	SetSome(ctx context.Context, in *InputsConfigSetSomeRequest, opts ...grpc.CallOption) (InputsConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *InputsConfigDeleteRequest, opts ...grpc.CallOption) (*InputsConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *InputsConfigDeleteSomeRequest, opts ...grpc.CallOption) (InputsConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *InputsConfigDeleteAllRequest, opts ...grpc.CallOption) (InputsConfigService_DeleteAllClient, error)
}

type inputsConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInputsConfigServiceClient(cc grpc.ClientConnInterface) InputsConfigServiceClient {
	return &inputsConfigServiceClient{cc}
}

func (c *inputsConfigServiceClient) GetOne(ctx context.Context, in *InputsConfigRequest, opts ...grpc.CallOption) (*InputsConfigResponse, error) {
	out := new(InputsConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsConfigServiceClient) GetSome(ctx context.Context, in *InputsConfigSomeRequest, opts ...grpc.CallOption) (InputsConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[0], "/arista.studio.v1.InputsConfigService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceGetSomeClient{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 InputsConfigService_GetSomeClient interface {
	Recv() (*InputsConfigSomeResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) GetAll(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[1], "/arista.studio.v1.InputsConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceGetAllClient{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 InputsConfigService_GetAllClient interface {
	Recv() (*InputsConfigStreamResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) Subscribe(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[2], "/arista.studio.v1.InputsConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceSubscribeClient{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 InputsConfigService_SubscribeClient interface {
	Recv() (*InputsConfigStreamResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) GetMeta(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsConfigService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsConfigServiceClient) SubscribeMeta(ctx context.Context, in *InputsConfigStreamRequest, opts ...grpc.CallOption) (InputsConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[3], "/arista.studio.v1.InputsConfigService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceSubscribeMetaClient{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 InputsConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) Set(ctx context.Context, in *InputsConfigSetRequest, opts ...grpc.CallOption) (*InputsConfigSetResponse, error) {
	out := new(InputsConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsConfigServiceClient) SetSome(ctx context.Context, in *InputsConfigSetSomeRequest, opts ...grpc.CallOption) (InputsConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[4], "/arista.studio.v1.InputsConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceSetSomeClient{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 InputsConfigService_SetSomeClient interface {
	Recv() (*InputsConfigSetSomeResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) Delete(ctx context.Context, in *InputsConfigDeleteRequest, opts ...grpc.CallOption) (*InputsConfigDeleteResponse, error) {
	out := new(InputsConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.InputsConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inputsConfigServiceClient) DeleteSome(ctx context.Context, in *InputsConfigDeleteSomeRequest, opts ...grpc.CallOption) (InputsConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[5], "/arista.studio.v1.InputsConfigService/DeleteSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceDeleteSomeClient{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 InputsConfigService_DeleteSomeClient interface {
	Recv() (*InputsConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *inputsConfigServiceClient) DeleteAll(ctx context.Context, in *InputsConfigDeleteAllRequest, opts ...grpc.CallOption) (InputsConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &InputsConfigService_ServiceDesc.Streams[6], "/arista.studio.v1.InputsConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &inputsConfigServiceDeleteAllClient{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 InputsConfigService_DeleteAllClient interface {
	Recv() (*InputsConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type inputsConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// InputsConfigServiceServer is the server API for InputsConfigService service.
// All implementations must embed UnimplementedInputsConfigServiceServer
// for forward compatibility
type InputsConfigServiceServer interface {
	GetOne(context.Context, *InputsConfigRequest) (*InputsConfigResponse, error)
	GetSome(*InputsConfigSomeRequest, InputsConfigService_GetSomeServer) error
	GetAll(*InputsConfigStreamRequest, InputsConfigService_GetAllServer) error
	Subscribe(*InputsConfigStreamRequest, InputsConfigService_SubscribeServer) error
	GetMeta(context.Context, *InputsConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*InputsConfigStreamRequest, InputsConfigService_SubscribeMetaServer) error
	Set(context.Context, *InputsConfigSetRequest) (*InputsConfigSetResponse, error)
	SetSome(*InputsConfigSetSomeRequest, InputsConfigService_SetSomeServer) error
	Delete(context.Context, *InputsConfigDeleteRequest) (*InputsConfigDeleteResponse, error)
	DeleteSome(*InputsConfigDeleteSomeRequest, InputsConfigService_DeleteSomeServer) error
	DeleteAll(*InputsConfigDeleteAllRequest, InputsConfigService_DeleteAllServer) error
	mustEmbedUnimplementedInputsConfigServiceServer()
}

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

func (UnimplementedInputsConfigServiceServer) GetOne(context.Context, *InputsConfigRequest) (*InputsConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedInputsConfigServiceServer) GetSome(*InputsConfigSomeRequest, InputsConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedInputsConfigServiceServer) GetAll(*InputsConfigStreamRequest, InputsConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedInputsConfigServiceServer) Subscribe(*InputsConfigStreamRequest, InputsConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedInputsConfigServiceServer) GetMeta(context.Context, *InputsConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedInputsConfigServiceServer) SubscribeMeta(*InputsConfigStreamRequest, InputsConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedInputsConfigServiceServer) Set(context.Context, *InputsConfigSetRequest) (*InputsConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedInputsConfigServiceServer) SetSome(*InputsConfigSetSomeRequest, InputsConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedInputsConfigServiceServer) Delete(context.Context, *InputsConfigDeleteRequest) (*InputsConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedInputsConfigServiceServer) DeleteSome(*InputsConfigDeleteSomeRequest, InputsConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedInputsConfigServiceServer) DeleteAll(*InputsConfigDeleteAllRequest, InputsConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedInputsConfigServiceServer) mustEmbedUnimplementedInputsConfigServiceServer() {}

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

func RegisterInputsConfigServiceServer(s grpc.ServiceRegistrar, srv InputsConfigServiceServer) {
	s.RegisterService(&InputsConfigService_ServiceDesc, srv)
}

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

func _InputsConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).GetSome(m, &inputsConfigServiceGetSomeServer{stream})
}

type InputsConfigService_GetSomeServer interface {
	Send(*InputsConfigSomeResponse) error
	grpc.ServerStream
}

type inputsConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceGetSomeServer) Send(m *InputsConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).GetAll(m, &inputsConfigServiceGetAllServer{stream})
}

type InputsConfigService_GetAllServer interface {
	Send(*InputsConfigStreamResponse) error
	grpc.ServerStream
}

type inputsConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceGetAllServer) Send(m *InputsConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).Subscribe(m, &inputsConfigServiceSubscribeServer{stream})
}

type InputsConfigService_SubscribeServer interface {
	Send(*InputsConfigStreamResponse) error
	grpc.ServerStream
}

type inputsConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceSubscribeServer) Send(m *InputsConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsConfigService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InputsConfigStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InputsConfigServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.InputsConfigService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InputsConfigServiceServer).GetMeta(ctx, req.(*InputsConfigStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InputsConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).SubscribeMeta(m, &inputsConfigServiceSubscribeMetaServer{stream})
}

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

type inputsConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _InputsConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).SetSome(m, &inputsConfigServiceSetSomeServer{stream})
}

type InputsConfigService_SetSomeServer interface {
	Send(*InputsConfigSetSomeResponse) error
	grpc.ServerStream
}

type inputsConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceSetSomeServer) Send(m *InputsConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _InputsConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).DeleteSome(m, &inputsConfigServiceDeleteSomeServer{stream})
}

type InputsConfigService_DeleteSomeServer interface {
	Send(*InputsConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type inputsConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceDeleteSomeServer) Send(m *InputsConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _InputsConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InputsConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InputsConfigServiceServer).DeleteAll(m, &inputsConfigServiceDeleteAllServer{stream})
}

type InputsConfigService_DeleteAllServer interface {
	Send(*InputsConfigDeleteAllResponse) error
	grpc.ServerStream
}

type inputsConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *inputsConfigServiceDeleteAllServer) Send(m *InputsConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// InputsConfigService_ServiceDesc is the grpc.ServiceDesc for InputsConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InputsConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.InputsConfigService",
	HandlerType: (*InputsConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _InputsConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _InputsConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _InputsConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _InputsConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _InputsConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _InputsConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _InputsConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _InputsConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _InputsConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _InputsConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _InputsConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// SecretInputServiceClient is the client API for SecretInputService 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 SecretInputServiceClient interface {
	GetOne(ctx context.Context, in *SecretInputRequest, opts ...grpc.CallOption) (*SecretInputResponse, error)
	GetSome(ctx context.Context, in *SecretInputSomeRequest, opts ...grpc.CallOption) (SecretInputService_GetSomeClient, error)
	GetAll(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_GetAllClient, error)
	Subscribe(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_SubscribeMetaClient, error)
}

type secretInputServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSecretInputServiceClient(cc grpc.ClientConnInterface) SecretInputServiceClient {
	return &secretInputServiceClient{cc}
}

func (c *secretInputServiceClient) GetOne(ctx context.Context, in *SecretInputRequest, opts ...grpc.CallOption) (*SecretInputResponse, error) {
	out := new(SecretInputResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.SecretInputService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *secretInputServiceClient) GetSome(ctx context.Context, in *SecretInputSomeRequest, opts ...grpc.CallOption) (SecretInputService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SecretInputService_ServiceDesc.Streams[0], "/arista.studio.v1.SecretInputService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &secretInputServiceGetSomeClient{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 SecretInputService_GetSomeClient interface {
	Recv() (*SecretInputSomeResponse, error)
	grpc.ClientStream
}

type secretInputServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *secretInputServiceClient) GetAll(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &SecretInputService_ServiceDesc.Streams[1], "/arista.studio.v1.SecretInputService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &secretInputServiceGetAllClient{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 SecretInputService_GetAllClient interface {
	Recv() (*SecretInputStreamResponse, error)
	grpc.ClientStream
}

type secretInputServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *secretInputServiceClient) Subscribe(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SecretInputService_ServiceDesc.Streams[2], "/arista.studio.v1.SecretInputService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &secretInputServiceSubscribeClient{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 SecretInputService_SubscribeClient interface {
	Recv() (*SecretInputStreamResponse, error)
	grpc.ClientStream
}

type secretInputServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *secretInputServiceClient) GetMeta(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.SecretInputService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *secretInputServiceClient) SubscribeMeta(ctx context.Context, in *SecretInputStreamRequest, opts ...grpc.CallOption) (SecretInputService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &SecretInputService_ServiceDesc.Streams[3], "/arista.studio.v1.SecretInputService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &secretInputServiceSubscribeMetaClient{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 SecretInputService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type secretInputServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// SecretInputServiceServer is the server API for SecretInputService service.
// All implementations must embed UnimplementedSecretInputServiceServer
// for forward compatibility
type SecretInputServiceServer interface {
	GetOne(context.Context, *SecretInputRequest) (*SecretInputResponse, error)
	GetSome(*SecretInputSomeRequest, SecretInputService_GetSomeServer) error
	GetAll(*SecretInputStreamRequest, SecretInputService_GetAllServer) error
	Subscribe(*SecretInputStreamRequest, SecretInputService_SubscribeServer) error
	GetMeta(context.Context, *SecretInputStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*SecretInputStreamRequest, SecretInputService_SubscribeMetaServer) error
	mustEmbedUnimplementedSecretInputServiceServer()
}

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

func (UnimplementedSecretInputServiceServer) GetOne(context.Context, *SecretInputRequest) (*SecretInputResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedSecretInputServiceServer) GetSome(*SecretInputSomeRequest, SecretInputService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedSecretInputServiceServer) GetAll(*SecretInputStreamRequest, SecretInputService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedSecretInputServiceServer) Subscribe(*SecretInputStreamRequest, SecretInputService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedSecretInputServiceServer) GetMeta(context.Context, *SecretInputStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedSecretInputServiceServer) SubscribeMeta(*SecretInputStreamRequest, SecretInputService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedSecretInputServiceServer) mustEmbedUnimplementedSecretInputServiceServer() {}

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

func RegisterSecretInputServiceServer(s grpc.ServiceRegistrar, srv SecretInputServiceServer) {
	s.RegisterService(&SecretInputService_ServiceDesc, srv)
}

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

func _SecretInputService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SecretInputSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SecretInputServiceServer).GetSome(m, &secretInputServiceGetSomeServer{stream})
}

type SecretInputService_GetSomeServer interface {
	Send(*SecretInputSomeResponse) error
	grpc.ServerStream
}

type secretInputServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *secretInputServiceGetSomeServer) Send(m *SecretInputSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SecretInputService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SecretInputStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SecretInputServiceServer).GetAll(m, &secretInputServiceGetAllServer{stream})
}

type SecretInputService_GetAllServer interface {
	Send(*SecretInputStreamResponse) error
	grpc.ServerStream
}

type secretInputServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *secretInputServiceGetAllServer) Send(m *SecretInputStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SecretInputService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SecretInputStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SecretInputServiceServer).Subscribe(m, &secretInputServiceSubscribeServer{stream})
}

type SecretInputService_SubscribeServer interface {
	Send(*SecretInputStreamResponse) error
	grpc.ServerStream
}

type secretInputServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *secretInputServiceSubscribeServer) Send(m *SecretInputStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SecretInputService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SecretInputStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SecretInputServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.SecretInputService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SecretInputServiceServer).GetMeta(ctx, req.(*SecretInputStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SecretInputService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SecretInputStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SecretInputServiceServer).SubscribeMeta(m, &secretInputServiceSubscribeMetaServer{stream})
}

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

type secretInputServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// SecretInputService_ServiceDesc is the grpc.ServiceDesc for SecretInputService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SecretInputService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.SecretInputService",
	HandlerType: (*SecretInputServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _SecretInputService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _SecretInputService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _SecretInputService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _SecretInputService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _SecretInputService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _SecretInputService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// StudioServiceClient is the client API for StudioService 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 StudioServiceClient interface {
	GetOne(ctx context.Context, in *StudioRequest, opts ...grpc.CallOption) (*StudioResponse, error)
	GetSome(ctx context.Context, in *StudioSomeRequest, opts ...grpc.CallOption) (StudioService_GetSomeClient, error)
	GetAll(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_GetAllClient, error)
	Subscribe(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_SubscribeMetaClient, error)
}

type studioServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewStudioServiceClient(cc grpc.ClientConnInterface) StudioServiceClient {
	return &studioServiceClient{cc}
}

func (c *studioServiceClient) GetOne(ctx context.Context, in *StudioRequest, opts ...grpc.CallOption) (*StudioResponse, error) {
	out := new(StudioResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioServiceClient) GetSome(ctx context.Context, in *StudioSomeRequest, opts ...grpc.CallOption) (StudioService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioService_ServiceDesc.Streams[0], "/arista.studio.v1.StudioService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioServiceGetSomeClient{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 StudioService_GetSomeClient interface {
	Recv() (*StudioSomeResponse, error)
	grpc.ClientStream
}

type studioServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *studioServiceClient) GetAll(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioService_ServiceDesc.Streams[1], "/arista.studio.v1.StudioService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioServiceGetAllClient{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 StudioService_GetAllClient interface {
	Recv() (*StudioStreamResponse, error)
	grpc.ClientStream
}

type studioServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *studioServiceClient) Subscribe(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioService_ServiceDesc.Streams[2], "/arista.studio.v1.StudioService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioServiceSubscribeClient{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 StudioService_SubscribeClient interface {
	Recv() (*StudioStreamResponse, error)
	grpc.ClientStream
}

type studioServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *studioServiceClient) GetMeta(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioServiceClient) SubscribeMeta(ctx context.Context, in *StudioStreamRequest, opts ...grpc.CallOption) (StudioService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioService_ServiceDesc.Streams[3], "/arista.studio.v1.StudioService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioServiceSubscribeMetaClient{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 StudioService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type studioServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// StudioServiceServer is the server API for StudioService service.
// All implementations must embed UnimplementedStudioServiceServer
// for forward compatibility
type StudioServiceServer interface {
	GetOne(context.Context, *StudioRequest) (*StudioResponse, error)
	GetSome(*StudioSomeRequest, StudioService_GetSomeServer) error
	GetAll(*StudioStreamRequest, StudioService_GetAllServer) error
	Subscribe(*StudioStreamRequest, StudioService_SubscribeServer) error
	GetMeta(context.Context, *StudioStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*StudioStreamRequest, StudioService_SubscribeMetaServer) error
	mustEmbedUnimplementedStudioServiceServer()
}

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

func (UnimplementedStudioServiceServer) GetOne(context.Context, *StudioRequest) (*StudioResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedStudioServiceServer) GetSome(*StudioSomeRequest, StudioService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedStudioServiceServer) GetAll(*StudioStreamRequest, StudioService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedStudioServiceServer) Subscribe(*StudioStreamRequest, StudioService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedStudioServiceServer) GetMeta(context.Context, *StudioStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedStudioServiceServer) SubscribeMeta(*StudioStreamRequest, StudioService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedStudioServiceServer) mustEmbedUnimplementedStudioServiceServer() {}

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

func RegisterStudioServiceServer(s grpc.ServiceRegistrar, srv StudioServiceServer) {
	s.RegisterService(&StudioService_ServiceDesc, srv)
}

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

func _StudioService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioServiceServer).GetSome(m, &studioServiceGetSomeServer{stream})
}

type StudioService_GetSomeServer interface {
	Send(*StudioSomeResponse) error
	grpc.ServerStream
}

type studioServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *studioServiceGetSomeServer) Send(m *StudioSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioServiceServer).GetAll(m, &studioServiceGetAllServer{stream})
}

type StudioService_GetAllServer interface {
	Send(*StudioStreamResponse) error
	grpc.ServerStream
}

type studioServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *studioServiceGetAllServer) Send(m *StudioStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioServiceServer).Subscribe(m, &studioServiceSubscribeServer{stream})
}

type StudioService_SubscribeServer interface {
	Send(*StudioStreamResponse) error
	grpc.ServerStream
}

type studioServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *studioServiceSubscribeServer) Send(m *StudioStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StudioStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StudioServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.StudioService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StudioServiceServer).GetMeta(ctx, req.(*StudioStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StudioService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioServiceServer).SubscribeMeta(m, &studioServiceSubscribeMetaServer{stream})
}

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

type studioServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// StudioService_ServiceDesc is the grpc.ServiceDesc for StudioService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var StudioService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.StudioService",
	HandlerType: (*StudioServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _StudioService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _StudioService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _StudioService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _StudioService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _StudioService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _StudioService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// StudioConfigServiceClient is the client API for StudioConfigService 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 StudioConfigServiceClient interface {
	GetOne(ctx context.Context, in *StudioConfigRequest, opts ...grpc.CallOption) (*StudioConfigResponse, error)
	GetSome(ctx context.Context, in *StudioConfigSomeRequest, opts ...grpc.CallOption) (StudioConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *StudioConfigSetRequest, opts ...grpc.CallOption) (*StudioConfigSetResponse, error)
	SetSome(ctx context.Context, in *StudioConfigSetSomeRequest, opts ...grpc.CallOption) (StudioConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *StudioConfigDeleteRequest, opts ...grpc.CallOption) (*StudioConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *StudioConfigDeleteSomeRequest, opts ...grpc.CallOption) (StudioConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *StudioConfigDeleteAllRequest, opts ...grpc.CallOption) (StudioConfigService_DeleteAllClient, error)
}

type studioConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewStudioConfigServiceClient(cc grpc.ClientConnInterface) StudioConfigServiceClient {
	return &studioConfigServiceClient{cc}
}

func (c *studioConfigServiceClient) GetOne(ctx context.Context, in *StudioConfigRequest, opts ...grpc.CallOption) (*StudioConfigResponse, error) {
	out := new(StudioConfigResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioConfigService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioConfigServiceClient) GetSome(ctx context.Context, in *StudioConfigSomeRequest, opts ...grpc.CallOption) (StudioConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[0], "/arista.studio.v1.StudioConfigService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceGetSomeClient{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 StudioConfigService_GetSomeClient interface {
	Recv() (*StudioConfigSomeResponse, error)
	grpc.ClientStream
}

type studioConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) GetAll(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[1], "/arista.studio.v1.StudioConfigService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceGetAllClient{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 StudioConfigService_GetAllClient interface {
	Recv() (*StudioConfigStreamResponse, error)
	grpc.ClientStream
}

type studioConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) Subscribe(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[2], "/arista.studio.v1.StudioConfigService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceSubscribeClient{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 StudioConfigService_SubscribeClient interface {
	Recv() (*StudioConfigStreamResponse, error)
	grpc.ClientStream
}

type studioConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) GetMeta(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioConfigService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioConfigServiceClient) SubscribeMeta(ctx context.Context, in *StudioConfigStreamRequest, opts ...grpc.CallOption) (StudioConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[3], "/arista.studio.v1.StudioConfigService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceSubscribeMetaClient{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 StudioConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type studioConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) Set(ctx context.Context, in *StudioConfigSetRequest, opts ...grpc.CallOption) (*StudioConfigSetResponse, error) {
	out := new(StudioConfigSetResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioConfigService/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioConfigServiceClient) SetSome(ctx context.Context, in *StudioConfigSetSomeRequest, opts ...grpc.CallOption) (StudioConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[4], "/arista.studio.v1.StudioConfigService/SetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceSetSomeClient{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 StudioConfigService_SetSomeClient interface {
	Recv() (*StudioConfigSetSomeResponse, error)
	grpc.ClientStream
}

type studioConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) Delete(ctx context.Context, in *StudioConfigDeleteRequest, opts ...grpc.CallOption) (*StudioConfigDeleteResponse, error) {
	out := new(StudioConfigDeleteResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioConfigService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioConfigServiceClient) DeleteSome(ctx context.Context, in *StudioConfigDeleteSomeRequest, opts ...grpc.CallOption) (StudioConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[5], "/arista.studio.v1.StudioConfigService/DeleteSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceDeleteSomeClient{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 StudioConfigService_DeleteSomeClient interface {
	Recv() (*StudioConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type studioConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *studioConfigServiceClient) DeleteAll(ctx context.Context, in *StudioConfigDeleteAllRequest, opts ...grpc.CallOption) (StudioConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioConfigService_ServiceDesc.Streams[6], "/arista.studio.v1.StudioConfigService/DeleteAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioConfigServiceDeleteAllClient{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 StudioConfigService_DeleteAllClient interface {
	Recv() (*StudioConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type studioConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// StudioConfigServiceServer is the server API for StudioConfigService service.
// All implementations must embed UnimplementedStudioConfigServiceServer
// for forward compatibility
type StudioConfigServiceServer interface {
	GetOne(context.Context, *StudioConfigRequest) (*StudioConfigResponse, error)
	GetSome(*StudioConfigSomeRequest, StudioConfigService_GetSomeServer) error
	GetAll(*StudioConfigStreamRequest, StudioConfigService_GetAllServer) error
	Subscribe(*StudioConfigStreamRequest, StudioConfigService_SubscribeServer) error
	GetMeta(context.Context, *StudioConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*StudioConfigStreamRequest, StudioConfigService_SubscribeMetaServer) error
	Set(context.Context, *StudioConfigSetRequest) (*StudioConfigSetResponse, error)
	SetSome(*StudioConfigSetSomeRequest, StudioConfigService_SetSomeServer) error
	Delete(context.Context, *StudioConfigDeleteRequest) (*StudioConfigDeleteResponse, error)
	DeleteSome(*StudioConfigDeleteSomeRequest, StudioConfigService_DeleteSomeServer) error
	DeleteAll(*StudioConfigDeleteAllRequest, StudioConfigService_DeleteAllServer) error
	mustEmbedUnimplementedStudioConfigServiceServer()
}

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

func (UnimplementedStudioConfigServiceServer) GetOne(context.Context, *StudioConfigRequest) (*StudioConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedStudioConfigServiceServer) GetSome(*StudioConfigSomeRequest, StudioConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedStudioConfigServiceServer) GetAll(*StudioConfigStreamRequest, StudioConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedStudioConfigServiceServer) Subscribe(*StudioConfigStreamRequest, StudioConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedStudioConfigServiceServer) GetMeta(context.Context, *StudioConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedStudioConfigServiceServer) SubscribeMeta(*StudioConfigStreamRequest, StudioConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedStudioConfigServiceServer) Set(context.Context, *StudioConfigSetRequest) (*StudioConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedStudioConfigServiceServer) SetSome(*StudioConfigSetSomeRequest, StudioConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedStudioConfigServiceServer) Delete(context.Context, *StudioConfigDeleteRequest) (*StudioConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedStudioConfigServiceServer) DeleteSome(*StudioConfigDeleteSomeRequest, StudioConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedStudioConfigServiceServer) DeleteAll(*StudioConfigDeleteAllRequest, StudioConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedStudioConfigServiceServer) mustEmbedUnimplementedStudioConfigServiceServer() {}

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

func RegisterStudioConfigServiceServer(s grpc.ServiceRegistrar, srv StudioConfigServiceServer) {
	s.RegisterService(&StudioConfigService_ServiceDesc, srv)
}

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

func _StudioConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).GetSome(m, &studioConfigServiceGetSomeServer{stream})
}

type StudioConfigService_GetSomeServer interface {
	Send(*StudioConfigSomeResponse) error
	grpc.ServerStream
}

type studioConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceGetSomeServer) Send(m *StudioConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).GetAll(m, &studioConfigServiceGetAllServer{stream})
}

type StudioConfigService_GetAllServer interface {
	Send(*StudioConfigStreamResponse) error
	grpc.ServerStream
}

type studioConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceGetAllServer) Send(m *StudioConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).Subscribe(m, &studioConfigServiceSubscribeServer{stream})
}

type StudioConfigService_SubscribeServer interface {
	Send(*StudioConfigStreamResponse) error
	grpc.ServerStream
}

type studioConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceSubscribeServer) Send(m *StudioConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioConfigService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StudioConfigStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StudioConfigServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.StudioConfigService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StudioConfigServiceServer).GetMeta(ctx, req.(*StudioConfigStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StudioConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).SubscribeMeta(m, &studioConfigServiceSubscribeMetaServer{stream})
}

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

type studioConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _StudioConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).SetSome(m, &studioConfigServiceSetSomeServer{stream})
}

type StudioConfigService_SetSomeServer interface {
	Send(*StudioConfigSetSomeResponse) error
	grpc.ServerStream
}

type studioConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceSetSomeServer) Send(m *StudioConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _StudioConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).DeleteSome(m, &studioConfigServiceDeleteSomeServer{stream})
}

type StudioConfigService_DeleteSomeServer interface {
	Send(*StudioConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type studioConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceDeleteSomeServer) Send(m *StudioConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioConfigServiceServer).DeleteAll(m, &studioConfigServiceDeleteAllServer{stream})
}

type StudioConfigService_DeleteAllServer interface {
	Send(*StudioConfigDeleteAllResponse) error
	grpc.ServerStream
}

type studioConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *studioConfigServiceDeleteAllServer) Send(m *StudioConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// StudioConfigService_ServiceDesc is the grpc.ServiceDesc for StudioConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var StudioConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.StudioConfigService",
	HandlerType: (*StudioConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _StudioConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _StudioConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _StudioConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _StudioConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _StudioConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _StudioConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _StudioConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _StudioConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _StudioConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _StudioConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _StudioConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}

// StudioSummaryServiceClient is the client API for StudioSummaryService 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 StudioSummaryServiceClient interface {
	GetOne(ctx context.Context, in *StudioSummaryRequest, opts ...grpc.CallOption) (*StudioSummaryResponse, error)
	GetSome(ctx context.Context, in *StudioSummarySomeRequest, opts ...grpc.CallOption) (StudioSummaryService_GetSomeClient, error)
	GetAll(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_GetAllClient, error)
	Subscribe(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_SubscribeMetaClient, error)
}

type studioSummaryServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewStudioSummaryServiceClient(cc grpc.ClientConnInterface) StudioSummaryServiceClient {
	return &studioSummaryServiceClient{cc}
}

func (c *studioSummaryServiceClient) GetOne(ctx context.Context, in *StudioSummaryRequest, opts ...grpc.CallOption) (*StudioSummaryResponse, error) {
	out := new(StudioSummaryResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioSummaryService/GetOne", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioSummaryServiceClient) GetSome(ctx context.Context, in *StudioSummarySomeRequest, opts ...grpc.CallOption) (StudioSummaryService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioSummaryService_ServiceDesc.Streams[0], "/arista.studio.v1.StudioSummaryService/GetSome", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioSummaryServiceGetSomeClient{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 StudioSummaryService_GetSomeClient interface {
	Recv() (*StudioSummarySomeResponse, error)
	grpc.ClientStream
}

type studioSummaryServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *studioSummaryServiceClient) GetAll(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioSummaryService_ServiceDesc.Streams[1], "/arista.studio.v1.StudioSummaryService/GetAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioSummaryServiceGetAllClient{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 StudioSummaryService_GetAllClient interface {
	Recv() (*StudioSummaryStreamResponse, error)
	grpc.ClientStream
}

type studioSummaryServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *studioSummaryServiceClient) Subscribe(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioSummaryService_ServiceDesc.Streams[2], "/arista.studio.v1.StudioSummaryService/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioSummaryServiceSubscribeClient{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 StudioSummaryService_SubscribeClient interface {
	Recv() (*StudioSummaryStreamResponse, error)
	grpc.ClientStream
}

type studioSummaryServiceSubscribeClient struct {
	grpc.ClientStream
}

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

func (c *studioSummaryServiceClient) GetMeta(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error) {
	out := new(MetaResponse)
	err := c.cc.Invoke(ctx, "/arista.studio.v1.StudioSummaryService/GetMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *studioSummaryServiceClient) SubscribeMeta(ctx context.Context, in *StudioSummaryStreamRequest, opts ...grpc.CallOption) (StudioSummaryService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &StudioSummaryService_ServiceDesc.Streams[3], "/arista.studio.v1.StudioSummaryService/SubscribeMeta", opts...)
	if err != nil {
		return nil, err
	}
	x := &studioSummaryServiceSubscribeMetaClient{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 StudioSummaryService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type studioSummaryServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

// StudioSummaryServiceServer is the server API for StudioSummaryService service.
// All implementations must embed UnimplementedStudioSummaryServiceServer
// for forward compatibility
type StudioSummaryServiceServer interface {
	GetOne(context.Context, *StudioSummaryRequest) (*StudioSummaryResponse, error)
	GetSome(*StudioSummarySomeRequest, StudioSummaryService_GetSomeServer) error
	GetAll(*StudioSummaryStreamRequest, StudioSummaryService_GetAllServer) error
	Subscribe(*StudioSummaryStreamRequest, StudioSummaryService_SubscribeServer) error
	GetMeta(context.Context, *StudioSummaryStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*StudioSummaryStreamRequest, StudioSummaryService_SubscribeMetaServer) error
	mustEmbedUnimplementedStudioSummaryServiceServer()
}

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

func (UnimplementedStudioSummaryServiceServer) GetOne(context.Context, *StudioSummaryRequest) (*StudioSummaryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedStudioSummaryServiceServer) GetSome(*StudioSummarySomeRequest, StudioSummaryService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedStudioSummaryServiceServer) GetAll(*StudioSummaryStreamRequest, StudioSummaryService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedStudioSummaryServiceServer) Subscribe(*StudioSummaryStreamRequest, StudioSummaryService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedStudioSummaryServiceServer) GetMeta(context.Context, *StudioSummaryStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedStudioSummaryServiceServer) SubscribeMeta(*StudioSummaryStreamRequest, StudioSummaryService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedStudioSummaryServiceServer) mustEmbedUnimplementedStudioSummaryServiceServer() {}

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

func RegisterStudioSummaryServiceServer(s grpc.ServiceRegistrar, srv StudioSummaryServiceServer) {
	s.RegisterService(&StudioSummaryService_ServiceDesc, srv)
}

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

func _StudioSummaryService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioSummarySomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioSummaryServiceServer).GetSome(m, &studioSummaryServiceGetSomeServer{stream})
}

type StudioSummaryService_GetSomeServer interface {
	Send(*StudioSummarySomeResponse) error
	grpc.ServerStream
}

type studioSummaryServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *studioSummaryServiceGetSomeServer) Send(m *StudioSummarySomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioSummaryService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioSummaryStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioSummaryServiceServer).GetAll(m, &studioSummaryServiceGetAllServer{stream})
}

type StudioSummaryService_GetAllServer interface {
	Send(*StudioSummaryStreamResponse) error
	grpc.ServerStream
}

type studioSummaryServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *studioSummaryServiceGetAllServer) Send(m *StudioSummaryStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioSummaryService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioSummaryStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioSummaryServiceServer).Subscribe(m, &studioSummaryServiceSubscribeServer{stream})
}

type StudioSummaryService_SubscribeServer interface {
	Send(*StudioSummaryStreamResponse) error
	grpc.ServerStream
}

type studioSummaryServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *studioSummaryServiceSubscribeServer) Send(m *StudioSummaryStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _StudioSummaryService_GetMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StudioSummaryStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StudioSummaryServiceServer).GetMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arista.studio.v1.StudioSummaryService/GetMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StudioSummaryServiceServer).GetMeta(ctx, req.(*StudioSummaryStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StudioSummaryService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StudioSummaryStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StudioSummaryServiceServer).SubscribeMeta(m, &studioSummaryServiceSubscribeMetaServer{stream})
}

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

type studioSummaryServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

// StudioSummaryService_ServiceDesc is the grpc.ServiceDesc for StudioSummaryService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var StudioSummaryService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.studio.v1.StudioSummaryService",
	HandlerType: (*StudioSummaryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _StudioSummaryService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _StudioSummaryService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _StudioSummaryService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _StudioSummaryService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _StudioSummaryService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _StudioSummaryService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/studio.v1/services.gen.proto",
}