services.gen_grpc.pb.go

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

// CloudVision allows users to version control provisioning operations
// that impact device configuration and image management. A workspace is
// something like a git branch, within which changes can be made without
// immediately impacting a device's running configuration. Changes can be
// made, modified, and previewed in a workspace. Once satisfied with the
// set of changes, a user may submit a workspace to the "mainline" branch,
// allowing the changes to be propagated to devices via Change Controls.
//
// A workspace comprises a set of diff operations (e.g., add/modify/remove)
// that will be applied to the mainline if the workspace is submitted
// successfully.
//
// A workspace itself is generic and can be used for any conceivable
// set of device provisioning operations, but it is not capable of
// describing the specific kind of changes. Rather, it holds changes
// defined by other Resource APIs that are "workspace-aware", such as
// studio.v1 and tag.v2. These APIs allow users to make changes within
// the context of a specific workspace, identified in the resource key
// with the field `workspace_id`.

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

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

package workspace

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

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

const (
	WorkspaceService_GetOne_FullMethodName           = "/arista.workspace.v1.WorkspaceService/GetOne"
	WorkspaceService_GetSome_FullMethodName          = "/arista.workspace.v1.WorkspaceService/GetSome"
	WorkspaceService_GetAll_FullMethodName           = "/arista.workspace.v1.WorkspaceService/GetAll"
	WorkspaceService_Subscribe_FullMethodName        = "/arista.workspace.v1.WorkspaceService/Subscribe"
	WorkspaceService_GetMeta_FullMethodName          = "/arista.workspace.v1.WorkspaceService/GetMeta"
	WorkspaceService_SubscribeMeta_FullMethodName    = "/arista.workspace.v1.WorkspaceService/SubscribeMeta"
	WorkspaceService_GetAllBatched_FullMethodName    = "/arista.workspace.v1.WorkspaceService/GetAllBatched"
	WorkspaceService_SubscribeBatched_FullMethodName = "/arista.workspace.v1.WorkspaceService/SubscribeBatched"
)

// WorkspaceServiceClient is the client API for WorkspaceService 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 WorkspaceServiceClient interface {
	GetOne(ctx context.Context, in *WorkspaceRequest, opts ...grpc.CallOption) (*WorkspaceResponse, error)
	GetSome(ctx context.Context, in *WorkspaceSomeRequest, opts ...grpc.CallOption) (WorkspaceService_GetSomeClient, error)
	GetAll(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_GetAllClient, error)
	Subscribe(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeMetaClient, error)
	GetAllBatched(ctx context.Context, in *WorkspaceBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceService_GetAllBatchedClient, error)
	SubscribeBatched(ctx context.Context, in *WorkspaceBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeBatchedClient, error)
}

type workspaceServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWorkspaceServiceClient(cc grpc.ClientConnInterface) WorkspaceServiceClient {
	return &workspaceServiceClient{cc}
}

func (c *workspaceServiceClient) GetOne(ctx context.Context, in *WorkspaceRequest, opts ...grpc.CallOption) (*WorkspaceResponse, error) {
	out := new(WorkspaceResponse)
	err := c.cc.Invoke(ctx, WorkspaceService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceServiceClient) GetSome(ctx context.Context, in *WorkspaceSomeRequest, opts ...grpc.CallOption) (WorkspaceService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[0], WorkspaceService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceGetSomeClient{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 WorkspaceService_GetSomeClient interface {
	Recv() (*WorkspaceSomeResponse, error)
	grpc.ClientStream
}

type workspaceServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceServiceClient) GetAll(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[1], WorkspaceService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceGetAllClient{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 WorkspaceService_GetAllClient interface {
	Recv() (*WorkspaceStreamResponse, error)
	grpc.ClientStream
}

type workspaceServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *workspaceServiceClient) Subscribe(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[2], WorkspaceService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceSubscribeClient{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 WorkspaceService_SubscribeClient interface {
	Recv() (*WorkspaceStreamResponse, error)
	grpc.ClientStream
}

type workspaceServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *workspaceServiceClient) SubscribeMeta(ctx context.Context, in *WorkspaceStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[3], WorkspaceService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceSubscribeMetaClient{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 WorkspaceService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type workspaceServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *workspaceServiceClient) GetAllBatched(ctx context.Context, in *WorkspaceBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceService_GetAllBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[4], WorkspaceService_GetAllBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceGetAllBatchedClient{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 WorkspaceService_GetAllBatchedClient interface {
	Recv() (*WorkspaceBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceServiceGetAllBatchedClient struct {
	grpc.ClientStream
}

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

func (c *workspaceServiceClient) SubscribeBatched(ctx context.Context, in *WorkspaceBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceService_SubscribeBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceService_ServiceDesc.Streams[5], WorkspaceService_SubscribeBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceServiceSubscribeBatchedClient{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 WorkspaceService_SubscribeBatchedClient interface {
	Recv() (*WorkspaceBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceServiceSubscribeBatchedClient struct {
	grpc.ClientStream
}

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

// WorkspaceServiceServer is the server API for WorkspaceService service.
// All implementations must embed UnimplementedWorkspaceServiceServer
// for forward compatibility
type WorkspaceServiceServer interface {
	GetOne(context.Context, *WorkspaceRequest) (*WorkspaceResponse, error)
	GetSome(*WorkspaceSomeRequest, WorkspaceService_GetSomeServer) error
	GetAll(*WorkspaceStreamRequest, WorkspaceService_GetAllServer) error
	Subscribe(*WorkspaceStreamRequest, WorkspaceService_SubscribeServer) error
	GetMeta(context.Context, *WorkspaceStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*WorkspaceStreamRequest, WorkspaceService_SubscribeMetaServer) error
	GetAllBatched(*WorkspaceBatchedStreamRequest, WorkspaceService_GetAllBatchedServer) error
	SubscribeBatched(*WorkspaceBatchedStreamRequest, WorkspaceService_SubscribeBatchedServer) error
	mustEmbedUnimplementedWorkspaceServiceServer()
}

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

func (UnimplementedWorkspaceServiceServer) GetOne(context.Context, *WorkspaceRequest) (*WorkspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedWorkspaceServiceServer) GetSome(*WorkspaceSomeRequest, WorkspaceService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedWorkspaceServiceServer) GetAll(*WorkspaceStreamRequest, WorkspaceService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedWorkspaceServiceServer) Subscribe(*WorkspaceStreamRequest, WorkspaceService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedWorkspaceServiceServer) GetMeta(context.Context, *WorkspaceStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedWorkspaceServiceServer) SubscribeMeta(*WorkspaceStreamRequest, WorkspaceService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedWorkspaceServiceServer) GetAllBatched(*WorkspaceBatchedStreamRequest, WorkspaceService_GetAllBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAllBatched not implemented")
}
func (UnimplementedWorkspaceServiceServer) SubscribeBatched(*WorkspaceBatchedStreamRequest, WorkspaceService_SubscribeBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBatched not implemented")
}
func (UnimplementedWorkspaceServiceServer) mustEmbedUnimplementedWorkspaceServiceServer() {}

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

func RegisterWorkspaceServiceServer(s grpc.ServiceRegistrar, srv WorkspaceServiceServer) {
	s.RegisterService(&WorkspaceService_ServiceDesc, srv)
}

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

func _WorkspaceService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).GetSome(m, &workspaceServiceGetSomeServer{stream})
}

type WorkspaceService_GetSomeServer interface {
	Send(*WorkspaceSomeResponse) error
	grpc.ServerStream
}

type workspaceServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceServiceGetSomeServer) Send(m *WorkspaceSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).GetAll(m, &workspaceServiceGetAllServer{stream})
}

type WorkspaceService_GetAllServer interface {
	Send(*WorkspaceStreamResponse) error
	grpc.ServerStream
}

type workspaceServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *workspaceServiceGetAllServer) Send(m *WorkspaceStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).Subscribe(m, &workspaceServiceSubscribeServer{stream})
}

type WorkspaceService_SubscribeServer interface {
	Send(*WorkspaceStreamResponse) error
	grpc.ServerStream
}

type workspaceServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *workspaceServiceSubscribeServer) Send(m *WorkspaceStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _WorkspaceService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).SubscribeMeta(m, &workspaceServiceSubscribeMetaServer{stream})
}

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

type workspaceServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

func _WorkspaceService_GetAllBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).GetAllBatched(m, &workspaceServiceGetAllBatchedServer{stream})
}

type WorkspaceService_GetAllBatchedServer interface {
	Send(*WorkspaceBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceServiceGetAllBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceServiceGetAllBatchedServer) Send(m *WorkspaceBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceService_SubscribeBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceServiceServer).SubscribeBatched(m, &workspaceServiceSubscribeBatchedServer{stream})
}

type WorkspaceService_SubscribeBatchedServer interface {
	Send(*WorkspaceBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceServiceSubscribeBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceServiceSubscribeBatchedServer) Send(m *WorkspaceBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// WorkspaceService_ServiceDesc is the grpc.ServiceDesc for WorkspaceService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WorkspaceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.workspace.v1.WorkspaceService",
	HandlerType: (*WorkspaceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _WorkspaceService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _WorkspaceService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _WorkspaceService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _WorkspaceService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _WorkspaceService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _WorkspaceService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAllBatched",
			Handler:       _WorkspaceService_GetAllBatched_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeBatched",
			Handler:       _WorkspaceService_SubscribeBatched_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/workspace.v1/services.gen.proto",
}

const (
	WorkspaceBuildService_GetOne_FullMethodName           = "/arista.workspace.v1.WorkspaceBuildService/GetOne"
	WorkspaceBuildService_GetSome_FullMethodName          = "/arista.workspace.v1.WorkspaceBuildService/GetSome"
	WorkspaceBuildService_GetAll_FullMethodName           = "/arista.workspace.v1.WorkspaceBuildService/GetAll"
	WorkspaceBuildService_Subscribe_FullMethodName        = "/arista.workspace.v1.WorkspaceBuildService/Subscribe"
	WorkspaceBuildService_GetMeta_FullMethodName          = "/arista.workspace.v1.WorkspaceBuildService/GetMeta"
	WorkspaceBuildService_SubscribeMeta_FullMethodName    = "/arista.workspace.v1.WorkspaceBuildService/SubscribeMeta"
	WorkspaceBuildService_GetAllBatched_FullMethodName    = "/arista.workspace.v1.WorkspaceBuildService/GetAllBatched"
	WorkspaceBuildService_SubscribeBatched_FullMethodName = "/arista.workspace.v1.WorkspaceBuildService/SubscribeBatched"
)

// WorkspaceBuildServiceClient is the client API for WorkspaceBuildService 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 WorkspaceBuildServiceClient interface {
	GetOne(ctx context.Context, in *WorkspaceBuildRequest, opts ...grpc.CallOption) (*WorkspaceBuildResponse, error)
	GetSome(ctx context.Context, in *WorkspaceBuildSomeRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetSomeClient, error)
	GetAll(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetAllClient, error)
	Subscribe(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeMetaClient, error)
	GetAllBatched(ctx context.Context, in *WorkspaceBuildBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetAllBatchedClient, error)
	SubscribeBatched(ctx context.Context, in *WorkspaceBuildBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeBatchedClient, error)
}

type workspaceBuildServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWorkspaceBuildServiceClient(cc grpc.ClientConnInterface) WorkspaceBuildServiceClient {
	return &workspaceBuildServiceClient{cc}
}

func (c *workspaceBuildServiceClient) GetOne(ctx context.Context, in *WorkspaceBuildRequest, opts ...grpc.CallOption) (*WorkspaceBuildResponse, error) {
	out := new(WorkspaceBuildResponse)
	err := c.cc.Invoke(ctx, WorkspaceBuildService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceBuildServiceClient) GetSome(ctx context.Context, in *WorkspaceBuildSomeRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[0], WorkspaceBuildService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceGetSomeClient{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 WorkspaceBuildService_GetSomeClient interface {
	Recv() (*WorkspaceBuildSomeResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildServiceClient) GetAll(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[1], WorkspaceBuildService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceGetAllClient{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 WorkspaceBuildService_GetAllClient interface {
	Recv() (*WorkspaceBuildStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildServiceClient) Subscribe(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[2], WorkspaceBuildService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceSubscribeClient{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 WorkspaceBuildService_SubscribeClient interface {
	Recv() (*WorkspaceBuildStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *workspaceBuildServiceClient) SubscribeMeta(ctx context.Context, in *WorkspaceBuildStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[3], WorkspaceBuildService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceSubscribeMetaClient{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 WorkspaceBuildService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildServiceClient) GetAllBatched(ctx context.Context, in *WorkspaceBuildBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_GetAllBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[4], WorkspaceBuildService_GetAllBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceGetAllBatchedClient{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 WorkspaceBuildService_GetAllBatchedClient interface {
	Recv() (*WorkspaceBuildBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceGetAllBatchedClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildServiceClient) SubscribeBatched(ctx context.Context, in *WorkspaceBuildBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildService_SubscribeBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildService_ServiceDesc.Streams[5], WorkspaceBuildService_SubscribeBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildServiceSubscribeBatchedClient{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 WorkspaceBuildService_SubscribeBatchedClient interface {
	Recv() (*WorkspaceBuildBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildServiceSubscribeBatchedClient struct {
	grpc.ClientStream
}

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

// WorkspaceBuildServiceServer is the server API for WorkspaceBuildService service.
// All implementations must embed UnimplementedWorkspaceBuildServiceServer
// for forward compatibility
type WorkspaceBuildServiceServer interface {
	GetOne(context.Context, *WorkspaceBuildRequest) (*WorkspaceBuildResponse, error)
	GetSome(*WorkspaceBuildSomeRequest, WorkspaceBuildService_GetSomeServer) error
	GetAll(*WorkspaceBuildStreamRequest, WorkspaceBuildService_GetAllServer) error
	Subscribe(*WorkspaceBuildStreamRequest, WorkspaceBuildService_SubscribeServer) error
	GetMeta(context.Context, *WorkspaceBuildStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*WorkspaceBuildStreamRequest, WorkspaceBuildService_SubscribeMetaServer) error
	GetAllBatched(*WorkspaceBuildBatchedStreamRequest, WorkspaceBuildService_GetAllBatchedServer) error
	SubscribeBatched(*WorkspaceBuildBatchedStreamRequest, WorkspaceBuildService_SubscribeBatchedServer) error
	mustEmbedUnimplementedWorkspaceBuildServiceServer()
}

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

func (UnimplementedWorkspaceBuildServiceServer) GetOne(context.Context, *WorkspaceBuildRequest) (*WorkspaceBuildResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) GetSome(*WorkspaceBuildSomeRequest, WorkspaceBuildService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) GetAll(*WorkspaceBuildStreamRequest, WorkspaceBuildService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) Subscribe(*WorkspaceBuildStreamRequest, WorkspaceBuildService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) GetMeta(context.Context, *WorkspaceBuildStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) SubscribeMeta(*WorkspaceBuildStreamRequest, WorkspaceBuildService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) GetAllBatched(*WorkspaceBuildBatchedStreamRequest, WorkspaceBuildService_GetAllBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAllBatched not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) SubscribeBatched(*WorkspaceBuildBatchedStreamRequest, WorkspaceBuildService_SubscribeBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBatched not implemented")
}
func (UnimplementedWorkspaceBuildServiceServer) mustEmbedUnimplementedWorkspaceBuildServiceServer() {}

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

func RegisterWorkspaceBuildServiceServer(s grpc.ServiceRegistrar, srv WorkspaceBuildServiceServer) {
	s.RegisterService(&WorkspaceBuildService_ServiceDesc, srv)
}

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

func _WorkspaceBuildService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).GetSome(m, &workspaceBuildServiceGetSomeServer{stream})
}

type WorkspaceBuildService_GetSomeServer interface {
	Send(*WorkspaceBuildSomeResponse) error
	grpc.ServerStream
}

type workspaceBuildServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildServiceGetSomeServer) Send(m *WorkspaceBuildSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).GetAll(m, &workspaceBuildServiceGetAllServer{stream})
}

type WorkspaceBuildService_GetAllServer interface {
	Send(*WorkspaceBuildStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildServiceGetAllServer) Send(m *WorkspaceBuildStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).Subscribe(m, &workspaceBuildServiceSubscribeServer{stream})
}

type WorkspaceBuildService_SubscribeServer interface {
	Send(*WorkspaceBuildStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildServiceSubscribeServer) Send(m *WorkspaceBuildStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _WorkspaceBuildService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).SubscribeMeta(m, &workspaceBuildServiceSubscribeMetaServer{stream})
}

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

type workspaceBuildServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

func _WorkspaceBuildService_GetAllBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).GetAllBatched(m, &workspaceBuildServiceGetAllBatchedServer{stream})
}

type WorkspaceBuildService_GetAllBatchedServer interface {
	Send(*WorkspaceBuildBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildServiceGetAllBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildServiceGetAllBatchedServer) Send(m *WorkspaceBuildBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildService_SubscribeBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildServiceServer).SubscribeBatched(m, &workspaceBuildServiceSubscribeBatchedServer{stream})
}

type WorkspaceBuildService_SubscribeBatchedServer interface {
	Send(*WorkspaceBuildBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildServiceSubscribeBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildServiceSubscribeBatchedServer) Send(m *WorkspaceBuildBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// WorkspaceBuildService_ServiceDesc is the grpc.ServiceDesc for WorkspaceBuildService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WorkspaceBuildService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.workspace.v1.WorkspaceBuildService",
	HandlerType: (*WorkspaceBuildServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _WorkspaceBuildService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _WorkspaceBuildService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _WorkspaceBuildService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _WorkspaceBuildService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _WorkspaceBuildService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _WorkspaceBuildService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAllBatched",
			Handler:       _WorkspaceBuildService_GetAllBatched_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeBatched",
			Handler:       _WorkspaceBuildService_SubscribeBatched_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/workspace.v1/services.gen.proto",
}

const (
	WorkspaceBuildDetailsService_GetOne_FullMethodName           = "/arista.workspace.v1.WorkspaceBuildDetailsService/GetOne"
	WorkspaceBuildDetailsService_GetSome_FullMethodName          = "/arista.workspace.v1.WorkspaceBuildDetailsService/GetSome"
	WorkspaceBuildDetailsService_GetAll_FullMethodName           = "/arista.workspace.v1.WorkspaceBuildDetailsService/GetAll"
	WorkspaceBuildDetailsService_Subscribe_FullMethodName        = "/arista.workspace.v1.WorkspaceBuildDetailsService/Subscribe"
	WorkspaceBuildDetailsService_GetMeta_FullMethodName          = "/arista.workspace.v1.WorkspaceBuildDetailsService/GetMeta"
	WorkspaceBuildDetailsService_SubscribeMeta_FullMethodName    = "/arista.workspace.v1.WorkspaceBuildDetailsService/SubscribeMeta"
	WorkspaceBuildDetailsService_GetAllBatched_FullMethodName    = "/arista.workspace.v1.WorkspaceBuildDetailsService/GetAllBatched"
	WorkspaceBuildDetailsService_SubscribeBatched_FullMethodName = "/arista.workspace.v1.WorkspaceBuildDetailsService/SubscribeBatched"
)

// WorkspaceBuildDetailsServiceClient is the client API for WorkspaceBuildDetailsService 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 WorkspaceBuildDetailsServiceClient interface {
	GetOne(ctx context.Context, in *WorkspaceBuildDetailsRequest, opts ...grpc.CallOption) (*WorkspaceBuildDetailsResponse, error)
	GetSome(ctx context.Context, in *WorkspaceBuildDetailsSomeRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetSomeClient, error)
	GetAll(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetAllClient, error)
	Subscribe(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeMetaClient, error)
	GetAllBatched(ctx context.Context, in *WorkspaceBuildDetailsBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetAllBatchedClient, error)
	SubscribeBatched(ctx context.Context, in *WorkspaceBuildDetailsBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeBatchedClient, error)
}

type workspaceBuildDetailsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWorkspaceBuildDetailsServiceClient(cc grpc.ClientConnInterface) WorkspaceBuildDetailsServiceClient {
	return &workspaceBuildDetailsServiceClient{cc}
}

func (c *workspaceBuildDetailsServiceClient) GetOne(ctx context.Context, in *WorkspaceBuildDetailsRequest, opts ...grpc.CallOption) (*WorkspaceBuildDetailsResponse, error) {
	out := new(WorkspaceBuildDetailsResponse)
	err := c.cc.Invoke(ctx, WorkspaceBuildDetailsService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceBuildDetailsServiceClient) GetSome(ctx context.Context, in *WorkspaceBuildDetailsSomeRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[0], WorkspaceBuildDetailsService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceGetSomeClient{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 WorkspaceBuildDetailsService_GetSomeClient interface {
	Recv() (*WorkspaceBuildDetailsSomeResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildDetailsServiceClient) GetAll(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[1], WorkspaceBuildDetailsService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceGetAllClient{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 WorkspaceBuildDetailsService_GetAllClient interface {
	Recv() (*WorkspaceBuildDetailsStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildDetailsServiceClient) Subscribe(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[2], WorkspaceBuildDetailsService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceSubscribeClient{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 WorkspaceBuildDetailsService_SubscribeClient interface {
	Recv() (*WorkspaceBuildDetailsStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *workspaceBuildDetailsServiceClient) SubscribeMeta(ctx context.Context, in *WorkspaceBuildDetailsStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[3], WorkspaceBuildDetailsService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceSubscribeMetaClient{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 WorkspaceBuildDetailsService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildDetailsServiceClient) GetAllBatched(ctx context.Context, in *WorkspaceBuildDetailsBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_GetAllBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[4], WorkspaceBuildDetailsService_GetAllBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceGetAllBatchedClient{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 WorkspaceBuildDetailsService_GetAllBatchedClient interface {
	Recv() (*WorkspaceBuildDetailsBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceGetAllBatchedClient struct {
	grpc.ClientStream
}

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

func (c *workspaceBuildDetailsServiceClient) SubscribeBatched(ctx context.Context, in *WorkspaceBuildDetailsBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceBuildDetailsService_SubscribeBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceBuildDetailsService_ServiceDesc.Streams[5], WorkspaceBuildDetailsService_SubscribeBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceBuildDetailsServiceSubscribeBatchedClient{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 WorkspaceBuildDetailsService_SubscribeBatchedClient interface {
	Recv() (*WorkspaceBuildDetailsBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceBuildDetailsServiceSubscribeBatchedClient struct {
	grpc.ClientStream
}

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

// WorkspaceBuildDetailsServiceServer is the server API for WorkspaceBuildDetailsService service.
// All implementations must embed UnimplementedWorkspaceBuildDetailsServiceServer
// for forward compatibility
type WorkspaceBuildDetailsServiceServer interface {
	GetOne(context.Context, *WorkspaceBuildDetailsRequest) (*WorkspaceBuildDetailsResponse, error)
	GetSome(*WorkspaceBuildDetailsSomeRequest, WorkspaceBuildDetailsService_GetSomeServer) error
	GetAll(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_GetAllServer) error
	Subscribe(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_SubscribeServer) error
	GetMeta(context.Context, *WorkspaceBuildDetailsStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_SubscribeMetaServer) error
	GetAllBatched(*WorkspaceBuildDetailsBatchedStreamRequest, WorkspaceBuildDetailsService_GetAllBatchedServer) error
	SubscribeBatched(*WorkspaceBuildDetailsBatchedStreamRequest, WorkspaceBuildDetailsService_SubscribeBatchedServer) error
	mustEmbedUnimplementedWorkspaceBuildDetailsServiceServer()
}

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

func (UnimplementedWorkspaceBuildDetailsServiceServer) GetOne(context.Context, *WorkspaceBuildDetailsRequest) (*WorkspaceBuildDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) GetSome(*WorkspaceBuildDetailsSomeRequest, WorkspaceBuildDetailsService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) GetAll(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) Subscribe(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) GetMeta(context.Context, *WorkspaceBuildDetailsStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) SubscribeMeta(*WorkspaceBuildDetailsStreamRequest, WorkspaceBuildDetailsService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) GetAllBatched(*WorkspaceBuildDetailsBatchedStreamRequest, WorkspaceBuildDetailsService_GetAllBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAllBatched not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) SubscribeBatched(*WorkspaceBuildDetailsBatchedStreamRequest, WorkspaceBuildDetailsService_SubscribeBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBatched not implemented")
}
func (UnimplementedWorkspaceBuildDetailsServiceServer) mustEmbedUnimplementedWorkspaceBuildDetailsServiceServer() {
}

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

func RegisterWorkspaceBuildDetailsServiceServer(s grpc.ServiceRegistrar, srv WorkspaceBuildDetailsServiceServer) {
	s.RegisterService(&WorkspaceBuildDetailsService_ServiceDesc, srv)
}

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

func _WorkspaceBuildDetailsService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).GetSome(m, &workspaceBuildDetailsServiceGetSomeServer{stream})
}

type WorkspaceBuildDetailsService_GetSomeServer interface {
	Send(*WorkspaceBuildDetailsSomeResponse) error
	grpc.ServerStream
}

type workspaceBuildDetailsServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildDetailsServiceGetSomeServer) Send(m *WorkspaceBuildDetailsSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildDetailsService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).GetAll(m, &workspaceBuildDetailsServiceGetAllServer{stream})
}

type WorkspaceBuildDetailsService_GetAllServer interface {
	Send(*WorkspaceBuildDetailsStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildDetailsServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildDetailsServiceGetAllServer) Send(m *WorkspaceBuildDetailsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildDetailsService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).Subscribe(m, &workspaceBuildDetailsServiceSubscribeServer{stream})
}

type WorkspaceBuildDetailsService_SubscribeServer interface {
	Send(*WorkspaceBuildDetailsStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildDetailsServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildDetailsServiceSubscribeServer) Send(m *WorkspaceBuildDetailsStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _WorkspaceBuildDetailsService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).SubscribeMeta(m, &workspaceBuildDetailsServiceSubscribeMetaServer{stream})
}

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

type workspaceBuildDetailsServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

func _WorkspaceBuildDetailsService_GetAllBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).GetAllBatched(m, &workspaceBuildDetailsServiceGetAllBatchedServer{stream})
}

type WorkspaceBuildDetailsService_GetAllBatchedServer interface {
	Send(*WorkspaceBuildDetailsBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildDetailsServiceGetAllBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildDetailsServiceGetAllBatchedServer) Send(m *WorkspaceBuildDetailsBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceBuildDetailsService_SubscribeBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceBuildDetailsBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceBuildDetailsServiceServer).SubscribeBatched(m, &workspaceBuildDetailsServiceSubscribeBatchedServer{stream})
}

type WorkspaceBuildDetailsService_SubscribeBatchedServer interface {
	Send(*WorkspaceBuildDetailsBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceBuildDetailsServiceSubscribeBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceBuildDetailsServiceSubscribeBatchedServer) Send(m *WorkspaceBuildDetailsBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// WorkspaceBuildDetailsService_ServiceDesc is the grpc.ServiceDesc for WorkspaceBuildDetailsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WorkspaceBuildDetailsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.workspace.v1.WorkspaceBuildDetailsService",
	HandlerType: (*WorkspaceBuildDetailsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _WorkspaceBuildDetailsService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _WorkspaceBuildDetailsService_GetMeta_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _WorkspaceBuildDetailsService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _WorkspaceBuildDetailsService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _WorkspaceBuildDetailsService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _WorkspaceBuildDetailsService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAllBatched",
			Handler:       _WorkspaceBuildDetailsService_GetAllBatched_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeBatched",
			Handler:       _WorkspaceBuildDetailsService_SubscribeBatched_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/workspace.v1/services.gen.proto",
}

const (
	WorkspaceConfigService_GetOne_FullMethodName           = "/arista.workspace.v1.WorkspaceConfigService/GetOne"
	WorkspaceConfigService_GetSome_FullMethodName          = "/arista.workspace.v1.WorkspaceConfigService/GetSome"
	WorkspaceConfigService_GetAll_FullMethodName           = "/arista.workspace.v1.WorkspaceConfigService/GetAll"
	WorkspaceConfigService_Subscribe_FullMethodName        = "/arista.workspace.v1.WorkspaceConfigService/Subscribe"
	WorkspaceConfigService_GetMeta_FullMethodName          = "/arista.workspace.v1.WorkspaceConfigService/GetMeta"
	WorkspaceConfigService_SubscribeMeta_FullMethodName    = "/arista.workspace.v1.WorkspaceConfigService/SubscribeMeta"
	WorkspaceConfigService_Set_FullMethodName              = "/arista.workspace.v1.WorkspaceConfigService/Set"
	WorkspaceConfigService_SetSome_FullMethodName          = "/arista.workspace.v1.WorkspaceConfigService/SetSome"
	WorkspaceConfigService_Delete_FullMethodName           = "/arista.workspace.v1.WorkspaceConfigService/Delete"
	WorkspaceConfigService_DeleteSome_FullMethodName       = "/arista.workspace.v1.WorkspaceConfigService/DeleteSome"
	WorkspaceConfigService_DeleteAll_FullMethodName        = "/arista.workspace.v1.WorkspaceConfigService/DeleteAll"
	WorkspaceConfigService_GetAllBatched_FullMethodName    = "/arista.workspace.v1.WorkspaceConfigService/GetAllBatched"
	WorkspaceConfigService_SubscribeBatched_FullMethodName = "/arista.workspace.v1.WorkspaceConfigService/SubscribeBatched"
)

// WorkspaceConfigServiceClient is the client API for WorkspaceConfigService 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 WorkspaceConfigServiceClient interface {
	GetOne(ctx context.Context, in *WorkspaceConfigRequest, opts ...grpc.CallOption) (*WorkspaceConfigResponse, error)
	GetSome(ctx context.Context, in *WorkspaceConfigSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *WorkspaceConfigSetRequest, opts ...grpc.CallOption) (*WorkspaceConfigSetResponse, error)
	SetSome(ctx context.Context, in *WorkspaceConfigSetSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *WorkspaceConfigDeleteRequest, opts ...grpc.CallOption) (*WorkspaceConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *WorkspaceConfigDeleteSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *WorkspaceConfigDeleteAllRequest, opts ...grpc.CallOption) (WorkspaceConfigService_DeleteAllClient, error)
	GetAllBatched(ctx context.Context, in *WorkspaceConfigBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetAllBatchedClient, error)
	SubscribeBatched(ctx context.Context, in *WorkspaceConfigBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeBatchedClient, error)
}

type workspaceConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWorkspaceConfigServiceClient(cc grpc.ClientConnInterface) WorkspaceConfigServiceClient {
	return &workspaceConfigServiceClient{cc}
}

func (c *workspaceConfigServiceClient) GetOne(ctx context.Context, in *WorkspaceConfigRequest, opts ...grpc.CallOption) (*WorkspaceConfigResponse, error) {
	out := new(WorkspaceConfigResponse)
	err := c.cc.Invoke(ctx, WorkspaceConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceConfigServiceClient) GetSome(ctx context.Context, in *WorkspaceConfigSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[0], WorkspaceConfigService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceGetSomeClient{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 WorkspaceConfigService_GetSomeClient interface {
	Recv() (*WorkspaceConfigSomeResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) GetAll(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[1], WorkspaceConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceGetAllClient{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 WorkspaceConfigService_GetAllClient interface {
	Recv() (*WorkspaceConfigStreamResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) Subscribe(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[2], WorkspaceConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceSubscribeClient{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 WorkspaceConfigService_SubscribeClient interface {
	Recv() (*WorkspaceConfigStreamResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *workspaceConfigServiceClient) SubscribeMeta(ctx context.Context, in *WorkspaceConfigStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[3], WorkspaceConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceSubscribeMetaClient{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 WorkspaceConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) Set(ctx context.Context, in *WorkspaceConfigSetRequest, opts ...grpc.CallOption) (*WorkspaceConfigSetResponse, error) {
	out := new(WorkspaceConfigSetResponse)
	err := c.cc.Invoke(ctx, WorkspaceConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceConfigServiceClient) SetSome(ctx context.Context, in *WorkspaceConfigSetSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[4], WorkspaceConfigService_SetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceSetSomeClient{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 WorkspaceConfigService_SetSomeClient interface {
	Recv() (*WorkspaceConfigSetSomeResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) Delete(ctx context.Context, in *WorkspaceConfigDeleteRequest, opts ...grpc.CallOption) (*WorkspaceConfigDeleteResponse, error) {
	out := new(WorkspaceConfigDeleteResponse)
	err := c.cc.Invoke(ctx, WorkspaceConfigService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workspaceConfigServiceClient) DeleteSome(ctx context.Context, in *WorkspaceConfigDeleteSomeRequest, opts ...grpc.CallOption) (WorkspaceConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[5], WorkspaceConfigService_DeleteSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceDeleteSomeClient{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 WorkspaceConfigService_DeleteSomeClient interface {
	Recv() (*WorkspaceConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) DeleteAll(ctx context.Context, in *WorkspaceConfigDeleteAllRequest, opts ...grpc.CallOption) (WorkspaceConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[6], WorkspaceConfigService_DeleteAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceDeleteAllClient{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 WorkspaceConfigService_DeleteAllClient interface {
	Recv() (*WorkspaceConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) GetAllBatched(ctx context.Context, in *WorkspaceConfigBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_GetAllBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[7], WorkspaceConfigService_GetAllBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceGetAllBatchedClient{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 WorkspaceConfigService_GetAllBatchedClient interface {
	Recv() (*WorkspaceConfigBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceGetAllBatchedClient struct {
	grpc.ClientStream
}

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

func (c *workspaceConfigServiceClient) SubscribeBatched(ctx context.Context, in *WorkspaceConfigBatchedStreamRequest, opts ...grpc.CallOption) (WorkspaceConfigService_SubscribeBatchedClient, error) {
	stream, err := c.cc.NewStream(ctx, &WorkspaceConfigService_ServiceDesc.Streams[8], WorkspaceConfigService_SubscribeBatched_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &workspaceConfigServiceSubscribeBatchedClient{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 WorkspaceConfigService_SubscribeBatchedClient interface {
	Recv() (*WorkspaceConfigBatchedStreamResponse, error)
	grpc.ClientStream
}

type workspaceConfigServiceSubscribeBatchedClient struct {
	grpc.ClientStream
}

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

// WorkspaceConfigServiceServer is the server API for WorkspaceConfigService service.
// All implementations must embed UnimplementedWorkspaceConfigServiceServer
// for forward compatibility
type WorkspaceConfigServiceServer interface {
	GetOne(context.Context, *WorkspaceConfigRequest) (*WorkspaceConfigResponse, error)
	GetSome(*WorkspaceConfigSomeRequest, WorkspaceConfigService_GetSomeServer) error
	GetAll(*WorkspaceConfigStreamRequest, WorkspaceConfigService_GetAllServer) error
	Subscribe(*WorkspaceConfigStreamRequest, WorkspaceConfigService_SubscribeServer) error
	GetMeta(context.Context, *WorkspaceConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*WorkspaceConfigStreamRequest, WorkspaceConfigService_SubscribeMetaServer) error
	Set(context.Context, *WorkspaceConfigSetRequest) (*WorkspaceConfigSetResponse, error)
	SetSome(*WorkspaceConfigSetSomeRequest, WorkspaceConfigService_SetSomeServer) error
	Delete(context.Context, *WorkspaceConfigDeleteRequest) (*WorkspaceConfigDeleteResponse, error)
	DeleteSome(*WorkspaceConfigDeleteSomeRequest, WorkspaceConfigService_DeleteSomeServer) error
	DeleteAll(*WorkspaceConfigDeleteAllRequest, WorkspaceConfigService_DeleteAllServer) error
	GetAllBatched(*WorkspaceConfigBatchedStreamRequest, WorkspaceConfigService_GetAllBatchedServer) error
	SubscribeBatched(*WorkspaceConfigBatchedStreamRequest, WorkspaceConfigService_SubscribeBatchedServer) error
	mustEmbedUnimplementedWorkspaceConfigServiceServer()
}

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

func (UnimplementedWorkspaceConfigServiceServer) GetOne(context.Context, *WorkspaceConfigRequest) (*WorkspaceConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) GetSome(*WorkspaceConfigSomeRequest, WorkspaceConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) GetAll(*WorkspaceConfigStreamRequest, WorkspaceConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) Subscribe(*WorkspaceConfigStreamRequest, WorkspaceConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) GetMeta(context.Context, *WorkspaceConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) SubscribeMeta(*WorkspaceConfigStreamRequest, WorkspaceConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) Set(context.Context, *WorkspaceConfigSetRequest) (*WorkspaceConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) SetSome(*WorkspaceConfigSetSomeRequest, WorkspaceConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) Delete(context.Context, *WorkspaceConfigDeleteRequest) (*WorkspaceConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) DeleteSome(*WorkspaceConfigDeleteSomeRequest, WorkspaceConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) DeleteAll(*WorkspaceConfigDeleteAllRequest, WorkspaceConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) GetAllBatched(*WorkspaceConfigBatchedStreamRequest, WorkspaceConfigService_GetAllBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAllBatched not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) SubscribeBatched(*WorkspaceConfigBatchedStreamRequest, WorkspaceConfigService_SubscribeBatchedServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBatched not implemented")
}
func (UnimplementedWorkspaceConfigServiceServer) mustEmbedUnimplementedWorkspaceConfigServiceServer() {
}

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

func RegisterWorkspaceConfigServiceServer(s grpc.ServiceRegistrar, srv WorkspaceConfigServiceServer) {
	s.RegisterService(&WorkspaceConfigService_ServiceDesc, srv)
}

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

func _WorkspaceConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).GetSome(m, &workspaceConfigServiceGetSomeServer{stream})
}

type WorkspaceConfigService_GetSomeServer interface {
	Send(*WorkspaceConfigSomeResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceGetSomeServer) Send(m *WorkspaceConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).GetAll(m, &workspaceConfigServiceGetAllServer{stream})
}

type WorkspaceConfigService_GetAllServer interface {
	Send(*WorkspaceConfigStreamResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceGetAllServer) Send(m *WorkspaceConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).Subscribe(m, &workspaceConfigServiceSubscribeServer{stream})
}

type WorkspaceConfigService_SubscribeServer interface {
	Send(*WorkspaceConfigStreamResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceSubscribeServer) Send(m *WorkspaceConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _WorkspaceConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).SubscribeMeta(m, &workspaceConfigServiceSubscribeMetaServer{stream})
}

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

type workspaceConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _WorkspaceConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).SetSome(m, &workspaceConfigServiceSetSomeServer{stream})
}

type WorkspaceConfigService_SetSomeServer interface {
	Send(*WorkspaceConfigSetSomeResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceSetSomeServer) Send(m *WorkspaceConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _WorkspaceConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).DeleteSome(m, &workspaceConfigServiceDeleteSomeServer{stream})
}

type WorkspaceConfigService_DeleteSomeServer interface {
	Send(*WorkspaceConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceDeleteSomeServer) Send(m *WorkspaceConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).DeleteAll(m, &workspaceConfigServiceDeleteAllServer{stream})
}

type WorkspaceConfigService_DeleteAllServer interface {
	Send(*WorkspaceConfigDeleteAllResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceDeleteAllServer) Send(m *WorkspaceConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceConfigService_GetAllBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).GetAllBatched(m, &workspaceConfigServiceGetAllBatchedServer{stream})
}

type WorkspaceConfigService_GetAllBatchedServer interface {
	Send(*WorkspaceConfigBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceGetAllBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceGetAllBatchedServer) Send(m *WorkspaceConfigBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WorkspaceConfigService_SubscribeBatched_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WorkspaceConfigBatchedStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WorkspaceConfigServiceServer).SubscribeBatched(m, &workspaceConfigServiceSubscribeBatchedServer{stream})
}

type WorkspaceConfigService_SubscribeBatchedServer interface {
	Send(*WorkspaceConfigBatchedStreamResponse) error
	grpc.ServerStream
}

type workspaceConfigServiceSubscribeBatchedServer struct {
	grpc.ServerStream
}

func (x *workspaceConfigServiceSubscribeBatchedServer) Send(m *WorkspaceConfigBatchedStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

// WorkspaceConfigService_ServiceDesc is the grpc.ServiceDesc for WorkspaceConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WorkspaceConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.workspace.v1.WorkspaceConfigService",
	HandlerType: (*WorkspaceConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _WorkspaceConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _WorkspaceConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _WorkspaceConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _WorkspaceConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _WorkspaceConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _WorkspaceConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _WorkspaceConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _WorkspaceConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _WorkspaceConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _WorkspaceConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _WorkspaceConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAllBatched",
			Handler:       _WorkspaceConfigService_GetAllBatched_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeBatched",
			Handler:       _WorkspaceConfigService_SubscribeBatched_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/workspace.v1/services.gen.proto",
}