protection_manager_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.21.10
// source: prodvana/protection/protection_manager.proto

package protection

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 (
	ProtectionManager_ConfigureProtection_FullMethodName           = "/prodvana.protection.ProtectionManager/ConfigureProtection"
	ProtectionManager_ValidateConfigureProtection_FullMethodName   = "/prodvana.protection.ProtectionManager/ValidateConfigureProtection"
	ProtectionManager_ListProtections_FullMethodName               = "/prodvana.protection.ProtectionManager/ListProtections"
	ProtectionManager_GetProtection_FullMethodName                 = "/prodvana.protection.ProtectionManager/GetProtection"
	ProtectionManager_GetProtectionConfig_FullMethodName           = "/prodvana.protection.ProtectionManager/GetProtectionConfig"
	ProtectionManager_GetProtectionAttachmentConfig_FullMethodName = "/prodvana.protection.ProtectionManager/GetProtectionAttachmentConfig"
)

// ProtectionManagerClient is the client API for ProtectionManager 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 ProtectionManagerClient interface {
	ConfigureProtection(ctx context.Context, in *ConfigureProtectionReq, opts ...grpc.CallOption) (*ConfigureProtectionResp, error)
	ValidateConfigureProtection(ctx context.Context, in *ConfigureProtectionReq, opts ...grpc.CallOption) (*ValidateConfigureProtectionResp, error)
	ListProtections(ctx context.Context, in *ListProtectionsReq, opts ...grpc.CallOption) (*ListProtectionsResp, error)
	GetProtection(ctx context.Context, in *GetProtectionReq, opts ...grpc.CallOption) (*GetProtectionResp, error)
	GetProtectionConfig(ctx context.Context, in *GetProtectionConfigReq, opts ...grpc.CallOption) (*GetProtectionConfigResp, error)
	GetProtectionAttachmentConfig(ctx context.Context, in *GetProtectionAttachmentConfigReq, opts ...grpc.CallOption) (*GetProtectionAttachmentConfigResp, error)
}

type protectionManagerClient struct {
	cc grpc.ClientConnInterface
}

func NewProtectionManagerClient(cc grpc.ClientConnInterface) ProtectionManagerClient {
	return &protectionManagerClient{cc}
}

func (c *protectionManagerClient) ConfigureProtection(ctx context.Context, in *ConfigureProtectionReq, opts ...grpc.CallOption) (*ConfigureProtectionResp, error) {
	out := new(ConfigureProtectionResp)
	err := c.cc.Invoke(ctx, ProtectionManager_ConfigureProtection_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protectionManagerClient) ValidateConfigureProtection(ctx context.Context, in *ConfigureProtectionReq, opts ...grpc.CallOption) (*ValidateConfigureProtectionResp, error) {
	out := new(ValidateConfigureProtectionResp)
	err := c.cc.Invoke(ctx, ProtectionManager_ValidateConfigureProtection_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protectionManagerClient) ListProtections(ctx context.Context, in *ListProtectionsReq, opts ...grpc.CallOption) (*ListProtectionsResp, error) {
	out := new(ListProtectionsResp)
	err := c.cc.Invoke(ctx, ProtectionManager_ListProtections_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protectionManagerClient) GetProtection(ctx context.Context, in *GetProtectionReq, opts ...grpc.CallOption) (*GetProtectionResp, error) {
	out := new(GetProtectionResp)
	err := c.cc.Invoke(ctx, ProtectionManager_GetProtection_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protectionManagerClient) GetProtectionConfig(ctx context.Context, in *GetProtectionConfigReq, opts ...grpc.CallOption) (*GetProtectionConfigResp, error) {
	out := new(GetProtectionConfigResp)
	err := c.cc.Invoke(ctx, ProtectionManager_GetProtectionConfig_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protectionManagerClient) GetProtectionAttachmentConfig(ctx context.Context, in *GetProtectionAttachmentConfigReq, opts ...grpc.CallOption) (*GetProtectionAttachmentConfigResp, error) {
	out := new(GetProtectionAttachmentConfigResp)
	err := c.cc.Invoke(ctx, ProtectionManager_GetProtectionAttachmentConfig_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProtectionManagerServer is the server API for ProtectionManager service.
// All implementations must embed UnimplementedProtectionManagerServer
// for forward compatibility
type ProtectionManagerServer interface {
	ConfigureProtection(context.Context, *ConfigureProtectionReq) (*ConfigureProtectionResp, error)
	ValidateConfigureProtection(context.Context, *ConfigureProtectionReq) (*ValidateConfigureProtectionResp, error)
	ListProtections(context.Context, *ListProtectionsReq) (*ListProtectionsResp, error)
	GetProtection(context.Context, *GetProtectionReq) (*GetProtectionResp, error)
	GetProtectionConfig(context.Context, *GetProtectionConfigReq) (*GetProtectionConfigResp, error)
	GetProtectionAttachmentConfig(context.Context, *GetProtectionAttachmentConfigReq) (*GetProtectionAttachmentConfigResp, error)
	mustEmbedUnimplementedProtectionManagerServer()
}

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

func (UnimplementedProtectionManagerServer) ConfigureProtection(context.Context, *ConfigureProtectionReq) (*ConfigureProtectionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConfigureProtection not implemented")
}
func (UnimplementedProtectionManagerServer) ValidateConfigureProtection(context.Context, *ConfigureProtectionReq) (*ValidateConfigureProtectionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateConfigureProtection not implemented")
}
func (UnimplementedProtectionManagerServer) ListProtections(context.Context, *ListProtectionsReq) (*ListProtectionsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProtections not implemented")
}
func (UnimplementedProtectionManagerServer) GetProtection(context.Context, *GetProtectionReq) (*GetProtectionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProtection not implemented")
}
func (UnimplementedProtectionManagerServer) GetProtectionConfig(context.Context, *GetProtectionConfigReq) (*GetProtectionConfigResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProtectionConfig not implemented")
}
func (UnimplementedProtectionManagerServer) GetProtectionAttachmentConfig(context.Context, *GetProtectionAttachmentConfigReq) (*GetProtectionAttachmentConfigResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProtectionAttachmentConfig not implemented")
}
func (UnimplementedProtectionManagerServer) mustEmbedUnimplementedProtectionManagerServer() {}

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

func RegisterProtectionManagerServer(s grpc.ServiceRegistrar, srv ProtectionManagerServer) {
	s.RegisterService(&ProtectionManager_ServiceDesc, srv)
}

func _ProtectionManager_ConfigureProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigureProtectionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).ConfigureProtection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_ConfigureProtection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).ConfigureProtection(ctx, req.(*ConfigureProtectionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtectionManager_ValidateConfigureProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigureProtectionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).ValidateConfigureProtection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_ValidateConfigureProtection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).ValidateConfigureProtection(ctx, req.(*ConfigureProtectionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtectionManager_ListProtections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProtectionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).ListProtections(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_ListProtections_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).ListProtections(ctx, req.(*ListProtectionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtectionManager_GetProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProtectionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).GetProtection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_GetProtection_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).GetProtection(ctx, req.(*GetProtectionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtectionManager_GetProtectionConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProtectionConfigReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).GetProtectionConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_GetProtectionConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).GetProtectionConfig(ctx, req.(*GetProtectionConfigReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtectionManager_GetProtectionAttachmentConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProtectionAttachmentConfigReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtectionManagerServer).GetProtectionAttachmentConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProtectionManager_GetProtectionAttachmentConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtectionManagerServer).GetProtectionAttachmentConfig(ctx, req.(*GetProtectionAttachmentConfigReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ProtectionManager_ServiceDesc is the grpc.ServiceDesc for ProtectionManager service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ProtectionManager_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "prodvana.protection.ProtectionManager",
	HandlerType: (*ProtectionManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ConfigureProtection",
			Handler:    _ProtectionManager_ConfigureProtection_Handler,
		},
		{
			MethodName: "ValidateConfigureProtection",
			Handler:    _ProtectionManager_ValidateConfigureProtection_Handler,
		},
		{
			MethodName: "ListProtections",
			Handler:    _ProtectionManager_ListProtections_Handler,
		},
		{
			MethodName: "GetProtection",
			Handler:    _ProtectionManager_GetProtection_Handler,
		},
		{
			MethodName: "GetProtectionConfig",
			Handler:    _ProtectionManager_GetProtectionConfig_Handler,
		},
		{
			MethodName: "GetProtectionAttachmentConfig",
			Handler:    _ProtectionManager_GetProtectionAttachmentConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "prodvana/protection/protection_manager.proto",
}