services.gen_grpc.pb.go

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

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

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

package identityprovider

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 (
	OAuthConfigService_GetOne_FullMethodName        = "/arista.identityprovider.v1.OAuthConfigService/GetOne"
	OAuthConfigService_GetSome_FullMethodName       = "/arista.identityprovider.v1.OAuthConfigService/GetSome"
	OAuthConfigService_GetAll_FullMethodName        = "/arista.identityprovider.v1.OAuthConfigService/GetAll"
	OAuthConfigService_Subscribe_FullMethodName     = "/arista.identityprovider.v1.OAuthConfigService/Subscribe"
	OAuthConfigService_GetMeta_FullMethodName       = "/arista.identityprovider.v1.OAuthConfigService/GetMeta"
	OAuthConfigService_SubscribeMeta_FullMethodName = "/arista.identityprovider.v1.OAuthConfigService/SubscribeMeta"
	OAuthConfigService_Set_FullMethodName           = "/arista.identityprovider.v1.OAuthConfigService/Set"
	OAuthConfigService_SetSome_FullMethodName       = "/arista.identityprovider.v1.OAuthConfigService/SetSome"
	OAuthConfigService_Delete_FullMethodName        = "/arista.identityprovider.v1.OAuthConfigService/Delete"
	OAuthConfigService_DeleteSome_FullMethodName    = "/arista.identityprovider.v1.OAuthConfigService/DeleteSome"
	OAuthConfigService_DeleteAll_FullMethodName     = "/arista.identityprovider.v1.OAuthConfigService/DeleteAll"
)

// OAuthConfigServiceClient is the client API for OAuthConfigService 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 OAuthConfigServiceClient interface {
	GetOne(ctx context.Context, in *OAuthConfigRequest, opts ...grpc.CallOption) (*OAuthConfigResponse, error)
	GetSome(ctx context.Context, in *OAuthConfigSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *OAuthConfigSetRequest, opts ...grpc.CallOption) (*OAuthConfigSetResponse, error)
	SetSome(ctx context.Context, in *OAuthConfigSetSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *OAuthConfigDeleteRequest, opts ...grpc.CallOption) (*OAuthConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *OAuthConfigDeleteSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *OAuthConfigDeleteAllRequest, opts ...grpc.CallOption) (OAuthConfigService_DeleteAllClient, error)
}

type oAuthConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewOAuthConfigServiceClient(cc grpc.ClientConnInterface) OAuthConfigServiceClient {
	return &oAuthConfigServiceClient{cc}
}

func (c *oAuthConfigServiceClient) GetOne(ctx context.Context, in *OAuthConfigRequest, opts ...grpc.CallOption) (*OAuthConfigResponse, error) {
	out := new(OAuthConfigResponse)
	err := c.cc.Invoke(ctx, OAuthConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oAuthConfigServiceClient) GetSome(ctx context.Context, in *OAuthConfigSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[0], OAuthConfigService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceGetSomeClient{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 OAuthConfigService_GetSomeClient interface {
	Recv() (*OAuthConfigSomeResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *oAuthConfigServiceClient) GetAll(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[1], OAuthConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceGetAllClient{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 OAuthConfigService_GetAllClient interface {
	Recv() (*OAuthConfigStreamResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *oAuthConfigServiceClient) Subscribe(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[2], OAuthConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceSubscribeClient{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 OAuthConfigService_SubscribeClient interface {
	Recv() (*OAuthConfigStreamResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *oAuthConfigServiceClient) SubscribeMeta(ctx context.Context, in *OAuthConfigStreamRequest, opts ...grpc.CallOption) (OAuthConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[3], OAuthConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceSubscribeMetaClient{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 OAuthConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *oAuthConfigServiceClient) Set(ctx context.Context, in *OAuthConfigSetRequest, opts ...grpc.CallOption) (*OAuthConfigSetResponse, error) {
	out := new(OAuthConfigSetResponse)
	err := c.cc.Invoke(ctx, OAuthConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oAuthConfigServiceClient) SetSome(ctx context.Context, in *OAuthConfigSetSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[4], OAuthConfigService_SetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceSetSomeClient{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 OAuthConfigService_SetSomeClient interface {
	Recv() (*OAuthConfigSetSomeResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *oAuthConfigServiceClient) Delete(ctx context.Context, in *OAuthConfigDeleteRequest, opts ...grpc.CallOption) (*OAuthConfigDeleteResponse, error) {
	out := new(OAuthConfigDeleteResponse)
	err := c.cc.Invoke(ctx, OAuthConfigService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oAuthConfigServiceClient) DeleteSome(ctx context.Context, in *OAuthConfigDeleteSomeRequest, opts ...grpc.CallOption) (OAuthConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[5], OAuthConfigService_DeleteSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceDeleteSomeClient{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 OAuthConfigService_DeleteSomeClient interface {
	Recv() (*OAuthConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *oAuthConfigServiceClient) DeleteAll(ctx context.Context, in *OAuthConfigDeleteAllRequest, opts ...grpc.CallOption) (OAuthConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &OAuthConfigService_ServiceDesc.Streams[6], OAuthConfigService_DeleteAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &oAuthConfigServiceDeleteAllClient{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 OAuthConfigService_DeleteAllClient interface {
	Recv() (*OAuthConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type oAuthConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// OAuthConfigServiceServer is the server API for OAuthConfigService service.
// All implementations must embed UnimplementedOAuthConfigServiceServer
// for forward compatibility
type OAuthConfigServiceServer interface {
	GetOne(context.Context, *OAuthConfigRequest) (*OAuthConfigResponse, error)
	GetSome(*OAuthConfigSomeRequest, OAuthConfigService_GetSomeServer) error
	GetAll(*OAuthConfigStreamRequest, OAuthConfigService_GetAllServer) error
	Subscribe(*OAuthConfigStreamRequest, OAuthConfigService_SubscribeServer) error
	GetMeta(context.Context, *OAuthConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*OAuthConfigStreamRequest, OAuthConfigService_SubscribeMetaServer) error
	Set(context.Context, *OAuthConfigSetRequest) (*OAuthConfigSetResponse, error)
	SetSome(*OAuthConfigSetSomeRequest, OAuthConfigService_SetSomeServer) error
	Delete(context.Context, *OAuthConfigDeleteRequest) (*OAuthConfigDeleteResponse, error)
	DeleteSome(*OAuthConfigDeleteSomeRequest, OAuthConfigService_DeleteSomeServer) error
	DeleteAll(*OAuthConfigDeleteAllRequest, OAuthConfigService_DeleteAllServer) error
	mustEmbedUnimplementedOAuthConfigServiceServer()
}

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

func (UnimplementedOAuthConfigServiceServer) GetOne(context.Context, *OAuthConfigRequest) (*OAuthConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedOAuthConfigServiceServer) GetSome(*OAuthConfigSomeRequest, OAuthConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedOAuthConfigServiceServer) GetAll(*OAuthConfigStreamRequest, OAuthConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedOAuthConfigServiceServer) Subscribe(*OAuthConfigStreamRequest, OAuthConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedOAuthConfigServiceServer) GetMeta(context.Context, *OAuthConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedOAuthConfigServiceServer) SubscribeMeta(*OAuthConfigStreamRequest, OAuthConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedOAuthConfigServiceServer) Set(context.Context, *OAuthConfigSetRequest) (*OAuthConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedOAuthConfigServiceServer) SetSome(*OAuthConfigSetSomeRequest, OAuthConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedOAuthConfigServiceServer) Delete(context.Context, *OAuthConfigDeleteRequest) (*OAuthConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedOAuthConfigServiceServer) DeleteSome(*OAuthConfigDeleteSomeRequest, OAuthConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedOAuthConfigServiceServer) DeleteAll(*OAuthConfigDeleteAllRequest, OAuthConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedOAuthConfigServiceServer) mustEmbedUnimplementedOAuthConfigServiceServer() {}

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

func RegisterOAuthConfigServiceServer(s grpc.ServiceRegistrar, srv OAuthConfigServiceServer) {
	s.RegisterService(&OAuthConfigService_ServiceDesc, srv)
}

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

func _OAuthConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).GetSome(m, &oAuthConfigServiceGetSomeServer{stream})
}

type OAuthConfigService_GetSomeServer interface {
	Send(*OAuthConfigSomeResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceGetSomeServer) Send(m *OAuthConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _OAuthConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).GetAll(m, &oAuthConfigServiceGetAllServer{stream})
}

type OAuthConfigService_GetAllServer interface {
	Send(*OAuthConfigStreamResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceGetAllServer) Send(m *OAuthConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _OAuthConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).Subscribe(m, &oAuthConfigServiceSubscribeServer{stream})
}

type OAuthConfigService_SubscribeServer interface {
	Send(*OAuthConfigStreamResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceSubscribeServer) Send(m *OAuthConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _OAuthConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).SubscribeMeta(m, &oAuthConfigServiceSubscribeMetaServer{stream})
}

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

type oAuthConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _OAuthConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).SetSome(m, &oAuthConfigServiceSetSomeServer{stream})
}

type OAuthConfigService_SetSomeServer interface {
	Send(*OAuthConfigSetSomeResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceSetSomeServer) Send(m *OAuthConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _OAuthConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).DeleteSome(m, &oAuthConfigServiceDeleteSomeServer{stream})
}

type OAuthConfigService_DeleteSomeServer interface {
	Send(*OAuthConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceDeleteSomeServer) Send(m *OAuthConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _OAuthConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OAuthConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OAuthConfigServiceServer).DeleteAll(m, &oAuthConfigServiceDeleteAllServer{stream})
}

type OAuthConfigService_DeleteAllServer interface {
	Send(*OAuthConfigDeleteAllResponse) error
	grpc.ServerStream
}

type oAuthConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *oAuthConfigServiceDeleteAllServer) Send(m *OAuthConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// OAuthConfigService_ServiceDesc is the grpc.ServiceDesc for OAuthConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var OAuthConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.identityprovider.v1.OAuthConfigService",
	HandlerType: (*OAuthConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _OAuthConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _OAuthConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _OAuthConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _OAuthConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _OAuthConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _OAuthConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _OAuthConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _OAuthConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _OAuthConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _OAuthConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _OAuthConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/identityprovider.v1/services.gen.proto",
}

const (
	SAMLConfigService_GetOne_FullMethodName        = "/arista.identityprovider.v1.SAMLConfigService/GetOne"
	SAMLConfigService_GetSome_FullMethodName       = "/arista.identityprovider.v1.SAMLConfigService/GetSome"
	SAMLConfigService_GetAll_FullMethodName        = "/arista.identityprovider.v1.SAMLConfigService/GetAll"
	SAMLConfigService_Subscribe_FullMethodName     = "/arista.identityprovider.v1.SAMLConfigService/Subscribe"
	SAMLConfigService_GetMeta_FullMethodName       = "/arista.identityprovider.v1.SAMLConfigService/GetMeta"
	SAMLConfigService_SubscribeMeta_FullMethodName = "/arista.identityprovider.v1.SAMLConfigService/SubscribeMeta"
	SAMLConfigService_Set_FullMethodName           = "/arista.identityprovider.v1.SAMLConfigService/Set"
	SAMLConfigService_SetSome_FullMethodName       = "/arista.identityprovider.v1.SAMLConfigService/SetSome"
	SAMLConfigService_Delete_FullMethodName        = "/arista.identityprovider.v1.SAMLConfigService/Delete"
	SAMLConfigService_DeleteSome_FullMethodName    = "/arista.identityprovider.v1.SAMLConfigService/DeleteSome"
	SAMLConfigService_DeleteAll_FullMethodName     = "/arista.identityprovider.v1.SAMLConfigService/DeleteAll"
)

// SAMLConfigServiceClient is the client API for SAMLConfigService 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 SAMLConfigServiceClient interface {
	GetOne(ctx context.Context, in *SAMLConfigRequest, opts ...grpc.CallOption) (*SAMLConfigResponse, error)
	GetSome(ctx context.Context, in *SAMLConfigSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_GetSomeClient, error)
	GetAll(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_GetAllClient, error)
	Subscribe(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_SubscribeClient, error)
	GetMeta(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (*MetaResponse, error)
	SubscribeMeta(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_SubscribeMetaClient, error)
	Set(ctx context.Context, in *SAMLConfigSetRequest, opts ...grpc.CallOption) (*SAMLConfigSetResponse, error)
	SetSome(ctx context.Context, in *SAMLConfigSetSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_SetSomeClient, error)
	Delete(ctx context.Context, in *SAMLConfigDeleteRequest, opts ...grpc.CallOption) (*SAMLConfigDeleteResponse, error)
	DeleteSome(ctx context.Context, in *SAMLConfigDeleteSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_DeleteSomeClient, error)
	DeleteAll(ctx context.Context, in *SAMLConfigDeleteAllRequest, opts ...grpc.CallOption) (SAMLConfigService_DeleteAllClient, error)
}

type sAMLConfigServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSAMLConfigServiceClient(cc grpc.ClientConnInterface) SAMLConfigServiceClient {
	return &sAMLConfigServiceClient{cc}
}

func (c *sAMLConfigServiceClient) GetOne(ctx context.Context, in *SAMLConfigRequest, opts ...grpc.CallOption) (*SAMLConfigResponse, error) {
	out := new(SAMLConfigResponse)
	err := c.cc.Invoke(ctx, SAMLConfigService_GetOne_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sAMLConfigServiceClient) GetSome(ctx context.Context, in *SAMLConfigSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_GetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[0], SAMLConfigService_GetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceGetSomeClient{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 SAMLConfigService_GetSomeClient interface {
	Recv() (*SAMLConfigSomeResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceGetSomeClient struct {
	grpc.ClientStream
}

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

func (c *sAMLConfigServiceClient) GetAll(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_GetAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[1], SAMLConfigService_GetAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceGetAllClient{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 SAMLConfigService_GetAllClient interface {
	Recv() (*SAMLConfigStreamResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceGetAllClient struct {
	grpc.ClientStream
}

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

func (c *sAMLConfigServiceClient) Subscribe(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[2], SAMLConfigService_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceSubscribeClient{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 SAMLConfigService_SubscribeClient interface {
	Recv() (*SAMLConfigStreamResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceSubscribeClient struct {
	grpc.ClientStream
}

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

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

func (c *sAMLConfigServiceClient) SubscribeMeta(ctx context.Context, in *SAMLConfigStreamRequest, opts ...grpc.CallOption) (SAMLConfigService_SubscribeMetaClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[3], SAMLConfigService_SubscribeMeta_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceSubscribeMetaClient{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 SAMLConfigService_SubscribeMetaClient interface {
	Recv() (*MetaResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceSubscribeMetaClient struct {
	grpc.ClientStream
}

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

func (c *sAMLConfigServiceClient) Set(ctx context.Context, in *SAMLConfigSetRequest, opts ...grpc.CallOption) (*SAMLConfigSetResponse, error) {
	out := new(SAMLConfigSetResponse)
	err := c.cc.Invoke(ctx, SAMLConfigService_Set_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sAMLConfigServiceClient) SetSome(ctx context.Context, in *SAMLConfigSetSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_SetSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[4], SAMLConfigService_SetSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceSetSomeClient{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 SAMLConfigService_SetSomeClient interface {
	Recv() (*SAMLConfigSetSomeResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceSetSomeClient struct {
	grpc.ClientStream
}

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

func (c *sAMLConfigServiceClient) Delete(ctx context.Context, in *SAMLConfigDeleteRequest, opts ...grpc.CallOption) (*SAMLConfigDeleteResponse, error) {
	out := new(SAMLConfigDeleteResponse)
	err := c.cc.Invoke(ctx, SAMLConfigService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sAMLConfigServiceClient) DeleteSome(ctx context.Context, in *SAMLConfigDeleteSomeRequest, opts ...grpc.CallOption) (SAMLConfigService_DeleteSomeClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[5], SAMLConfigService_DeleteSome_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceDeleteSomeClient{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 SAMLConfigService_DeleteSomeClient interface {
	Recv() (*SAMLConfigDeleteSomeResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceDeleteSomeClient struct {
	grpc.ClientStream
}

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

func (c *sAMLConfigServiceClient) DeleteAll(ctx context.Context, in *SAMLConfigDeleteAllRequest, opts ...grpc.CallOption) (SAMLConfigService_DeleteAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &SAMLConfigService_ServiceDesc.Streams[6], SAMLConfigService_DeleteAll_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sAMLConfigServiceDeleteAllClient{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 SAMLConfigService_DeleteAllClient interface {
	Recv() (*SAMLConfigDeleteAllResponse, error)
	grpc.ClientStream
}

type sAMLConfigServiceDeleteAllClient struct {
	grpc.ClientStream
}

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

// SAMLConfigServiceServer is the server API for SAMLConfigService service.
// All implementations must embed UnimplementedSAMLConfigServiceServer
// for forward compatibility
type SAMLConfigServiceServer interface {
	GetOne(context.Context, *SAMLConfigRequest) (*SAMLConfigResponse, error)
	GetSome(*SAMLConfigSomeRequest, SAMLConfigService_GetSomeServer) error
	GetAll(*SAMLConfigStreamRequest, SAMLConfigService_GetAllServer) error
	Subscribe(*SAMLConfigStreamRequest, SAMLConfigService_SubscribeServer) error
	GetMeta(context.Context, *SAMLConfigStreamRequest) (*MetaResponse, error)
	SubscribeMeta(*SAMLConfigStreamRequest, SAMLConfigService_SubscribeMetaServer) error
	Set(context.Context, *SAMLConfigSetRequest) (*SAMLConfigSetResponse, error)
	SetSome(*SAMLConfigSetSomeRequest, SAMLConfigService_SetSomeServer) error
	Delete(context.Context, *SAMLConfigDeleteRequest) (*SAMLConfigDeleteResponse, error)
	DeleteSome(*SAMLConfigDeleteSomeRequest, SAMLConfigService_DeleteSomeServer) error
	DeleteAll(*SAMLConfigDeleteAllRequest, SAMLConfigService_DeleteAllServer) error
	mustEmbedUnimplementedSAMLConfigServiceServer()
}

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

func (UnimplementedSAMLConfigServiceServer) GetOne(context.Context, *SAMLConfigRequest) (*SAMLConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOne not implemented")
}
func (UnimplementedSAMLConfigServiceServer) GetSome(*SAMLConfigSomeRequest, SAMLConfigService_GetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSome not implemented")
}
func (UnimplementedSAMLConfigServiceServer) GetAll(*SAMLConfigStreamRequest, SAMLConfigService_GetAllServer) error {
	return status.Errorf(codes.Unimplemented, "method GetAll not implemented")
}
func (UnimplementedSAMLConfigServiceServer) Subscribe(*SAMLConfigStreamRequest, SAMLConfigService_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedSAMLConfigServiceServer) GetMeta(context.Context, *SAMLConfigStreamRequest) (*MetaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMeta not implemented")
}
func (UnimplementedSAMLConfigServiceServer) SubscribeMeta(*SAMLConfigStreamRequest, SAMLConfigService_SubscribeMetaServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeMeta not implemented")
}
func (UnimplementedSAMLConfigServiceServer) Set(context.Context, *SAMLConfigSetRequest) (*SAMLConfigSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedSAMLConfigServiceServer) SetSome(*SAMLConfigSetSomeRequest, SAMLConfigService_SetSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method SetSome not implemented")
}
func (UnimplementedSAMLConfigServiceServer) Delete(context.Context, *SAMLConfigDeleteRequest) (*SAMLConfigDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedSAMLConfigServiceServer) DeleteSome(*SAMLConfigDeleteSomeRequest, SAMLConfigService_DeleteSomeServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteSome not implemented")
}
func (UnimplementedSAMLConfigServiceServer) DeleteAll(*SAMLConfigDeleteAllRequest, SAMLConfigService_DeleteAllServer) error {
	return status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedSAMLConfigServiceServer) mustEmbedUnimplementedSAMLConfigServiceServer() {}

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

func RegisterSAMLConfigServiceServer(s grpc.ServiceRegistrar, srv SAMLConfigServiceServer) {
	s.RegisterService(&SAMLConfigService_ServiceDesc, srv)
}

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

func _SAMLConfigService_GetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).GetSome(m, &sAMLConfigServiceGetSomeServer{stream})
}

type SAMLConfigService_GetSomeServer interface {
	Send(*SAMLConfigSomeResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceGetSomeServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceGetSomeServer) Send(m *SAMLConfigSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SAMLConfigService_GetAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).GetAll(m, &sAMLConfigServiceGetAllServer{stream})
}

type SAMLConfigService_GetAllServer interface {
	Send(*SAMLConfigStreamResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceGetAllServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceGetAllServer) Send(m *SAMLConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SAMLConfigService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).Subscribe(m, &sAMLConfigServiceSubscribeServer{stream})
}

type SAMLConfigService_SubscribeServer interface {
	Send(*SAMLConfigStreamResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceSubscribeServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceSubscribeServer) Send(m *SAMLConfigStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _SAMLConfigService_SubscribeMeta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).SubscribeMeta(m, &sAMLConfigServiceSubscribeMetaServer{stream})
}

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

type sAMLConfigServiceSubscribeMetaServer struct {
	grpc.ServerStream
}

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

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

func _SAMLConfigService_SetSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigSetSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).SetSome(m, &sAMLConfigServiceSetSomeServer{stream})
}

type SAMLConfigService_SetSomeServer interface {
	Send(*SAMLConfigSetSomeResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceSetSomeServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceSetSomeServer) Send(m *SAMLConfigSetSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _SAMLConfigService_DeleteSome_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigDeleteSomeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).DeleteSome(m, &sAMLConfigServiceDeleteSomeServer{stream})
}

type SAMLConfigService_DeleteSomeServer interface {
	Send(*SAMLConfigDeleteSomeResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceDeleteSomeServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceDeleteSomeServer) Send(m *SAMLConfigDeleteSomeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SAMLConfigService_DeleteAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SAMLConfigDeleteAllRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SAMLConfigServiceServer).DeleteAll(m, &sAMLConfigServiceDeleteAllServer{stream})
}

type SAMLConfigService_DeleteAllServer interface {
	Send(*SAMLConfigDeleteAllResponse) error
	grpc.ServerStream
}

type sAMLConfigServiceDeleteAllServer struct {
	grpc.ServerStream
}

func (x *sAMLConfigServiceDeleteAllServer) Send(m *SAMLConfigDeleteAllResponse) error {
	return x.ServerStream.SendMsg(m)
}

// SAMLConfigService_ServiceDesc is the grpc.ServiceDesc for SAMLConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SAMLConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "arista.identityprovider.v1.SAMLConfigService",
	HandlerType: (*SAMLConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetOne",
			Handler:    _SAMLConfigService_GetOne_Handler,
		},
		{
			MethodName: "GetMeta",
			Handler:    _SAMLConfigService_GetMeta_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _SAMLConfigService_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _SAMLConfigService_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetSome",
			Handler:       _SAMLConfigService_GetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAll",
			Handler:       _SAMLConfigService_GetAll_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _SAMLConfigService_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeMeta",
			Handler:       _SAMLConfigService_SubscribeMeta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SetSome",
			Handler:       _SAMLConfigService_SetSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteSome",
			Handler:       _SAMLConfigService_DeleteSome_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DeleteAll",
			Handler:       _SAMLConfigService_DeleteAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "arista/identityprovider.v1/services.gen.proto",
}