// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             (unknown)
// source: global/nextgen/v1/reserved_capacity_template.proto

package nextgenv1

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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.62.0 or later.
const _ = grpc.SupportPackageIsVersion8

const (
	ReservedCapacityTemplateService_CreateReservedCapacityTemplate_FullMethodName       = "/global.nextgen.v1.ReservedCapacityTemplateService/CreateReservedCapacityTemplate"
	ReservedCapacityTemplateService_GetReservedCapacityTemplate_FullMethodName          = "/global.nextgen.v1.ReservedCapacityTemplateService/GetReservedCapacityTemplate"
	ReservedCapacityTemplateService_ListReservedCapacityTemplates_FullMethodName        = "/global.nextgen.v1.ReservedCapacityTemplateService/ListReservedCapacityTemplates"
	ReservedCapacityTemplateService_UpdateReservedCapacityTemplateStatus_FullMethodName = "/global.nextgen.v1.ReservedCapacityTemplateService/UpdateReservedCapacityTemplateStatus"
	ReservedCapacityTemplateService_DeleteReservedCapacityTemplate_FullMethodName       = "/global.nextgen.v1.ReservedCapacityTemplateService/DeleteReservedCapacityTemplate"
)

// ReservedCapacityTemplateServiceClient is the client API for ReservedCapacityTemplateService 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 ReservedCapacityTemplateServiceClient interface {
	CreateReservedCapacityTemplate(ctx context.Context, in *CreateReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error)
	GetReservedCapacityTemplate(ctx context.Context, in *GetReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error)
	ListReservedCapacityTemplates(ctx context.Context, in *ListReservedCapacityTemplatesRequest, opts ...grpc.CallOption) (*ListReservedCapacityTemplatesResponse, error)
	UpdateReservedCapacityTemplateStatus(ctx context.Context, in *UpdateReservedCapacityTemplateStatusRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error)
	DeleteReservedCapacityTemplate(ctx context.Context, in *DeleteReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type reservedCapacityTemplateServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewReservedCapacityTemplateServiceClient(cc grpc.ClientConnInterface) ReservedCapacityTemplateServiceClient {
	return &reservedCapacityTemplateServiceClient{cc}
}

func (c *reservedCapacityTemplateServiceClient) CreateReservedCapacityTemplate(ctx context.Context, in *CreateReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReservedCapacityTemplate)
	err := c.cc.Invoke(ctx, ReservedCapacityTemplateService_CreateReservedCapacityTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *reservedCapacityTemplateServiceClient) GetReservedCapacityTemplate(ctx context.Context, in *GetReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReservedCapacityTemplate)
	err := c.cc.Invoke(ctx, ReservedCapacityTemplateService_GetReservedCapacityTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *reservedCapacityTemplateServiceClient) ListReservedCapacityTemplates(ctx context.Context, in *ListReservedCapacityTemplatesRequest, opts ...grpc.CallOption) (*ListReservedCapacityTemplatesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListReservedCapacityTemplatesResponse)
	err := c.cc.Invoke(ctx, ReservedCapacityTemplateService_ListReservedCapacityTemplates_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *reservedCapacityTemplateServiceClient) UpdateReservedCapacityTemplateStatus(ctx context.Context, in *UpdateReservedCapacityTemplateStatusRequest, opts ...grpc.CallOption) (*ReservedCapacityTemplate, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReservedCapacityTemplate)
	err := c.cc.Invoke(ctx, ReservedCapacityTemplateService_UpdateReservedCapacityTemplateStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *reservedCapacityTemplateServiceClient) DeleteReservedCapacityTemplate(ctx context.Context, in *DeleteReservedCapacityTemplateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ReservedCapacityTemplateService_DeleteReservedCapacityTemplate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReservedCapacityTemplateServiceServer is the server API for ReservedCapacityTemplateService service.
// All implementations should embed UnimplementedReservedCapacityTemplateServiceServer
// for forward compatibility
type ReservedCapacityTemplateServiceServer interface {
	CreateReservedCapacityTemplate(context.Context, *CreateReservedCapacityTemplateRequest) (*ReservedCapacityTemplate, error)
	GetReservedCapacityTemplate(context.Context, *GetReservedCapacityTemplateRequest) (*ReservedCapacityTemplate, error)
	ListReservedCapacityTemplates(context.Context, *ListReservedCapacityTemplatesRequest) (*ListReservedCapacityTemplatesResponse, error)
	UpdateReservedCapacityTemplateStatus(context.Context, *UpdateReservedCapacityTemplateStatusRequest) (*ReservedCapacityTemplate, error)
	DeleteReservedCapacityTemplate(context.Context, *DeleteReservedCapacityTemplateRequest) (*emptypb.Empty, error)
}

// UnimplementedReservedCapacityTemplateServiceServer should be embedded to have forward compatible implementations.
type UnimplementedReservedCapacityTemplateServiceServer struct {
}

func (UnimplementedReservedCapacityTemplateServiceServer) CreateReservedCapacityTemplate(context.Context, *CreateReservedCapacityTemplateRequest) (*ReservedCapacityTemplate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateReservedCapacityTemplate not implemented")
}
func (UnimplementedReservedCapacityTemplateServiceServer) GetReservedCapacityTemplate(context.Context, *GetReservedCapacityTemplateRequest) (*ReservedCapacityTemplate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReservedCapacityTemplate not implemented")
}
func (UnimplementedReservedCapacityTemplateServiceServer) ListReservedCapacityTemplates(context.Context, *ListReservedCapacityTemplatesRequest) (*ListReservedCapacityTemplatesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListReservedCapacityTemplates not implemented")
}
func (UnimplementedReservedCapacityTemplateServiceServer) UpdateReservedCapacityTemplateStatus(context.Context, *UpdateReservedCapacityTemplateStatusRequest) (*ReservedCapacityTemplate, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateReservedCapacityTemplateStatus not implemented")
}
func (UnimplementedReservedCapacityTemplateServiceServer) DeleteReservedCapacityTemplate(context.Context, *DeleteReservedCapacityTemplateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteReservedCapacityTemplate not implemented")
}

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

func RegisterReservedCapacityTemplateServiceServer(s grpc.ServiceRegistrar, srv ReservedCapacityTemplateServiceServer) {
	s.RegisterService(&ReservedCapacityTemplateService_ServiceDesc, srv)
}

func _ReservedCapacityTemplateService_CreateReservedCapacityTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateReservedCapacityTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReservedCapacityTemplateServiceServer).CreateReservedCapacityTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReservedCapacityTemplateService_CreateReservedCapacityTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReservedCapacityTemplateServiceServer).CreateReservedCapacityTemplate(ctx, req.(*CreateReservedCapacityTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReservedCapacityTemplateService_GetReservedCapacityTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetReservedCapacityTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReservedCapacityTemplateServiceServer).GetReservedCapacityTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReservedCapacityTemplateService_GetReservedCapacityTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReservedCapacityTemplateServiceServer).GetReservedCapacityTemplate(ctx, req.(*GetReservedCapacityTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReservedCapacityTemplateService_ListReservedCapacityTemplates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListReservedCapacityTemplatesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReservedCapacityTemplateServiceServer).ListReservedCapacityTemplates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReservedCapacityTemplateService_ListReservedCapacityTemplates_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReservedCapacityTemplateServiceServer).ListReservedCapacityTemplates(ctx, req.(*ListReservedCapacityTemplatesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReservedCapacityTemplateService_UpdateReservedCapacityTemplateStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateReservedCapacityTemplateStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReservedCapacityTemplateServiceServer).UpdateReservedCapacityTemplateStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReservedCapacityTemplateService_UpdateReservedCapacityTemplateStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReservedCapacityTemplateServiceServer).UpdateReservedCapacityTemplateStatus(ctx, req.(*UpdateReservedCapacityTemplateStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReservedCapacityTemplateService_DeleteReservedCapacityTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteReservedCapacityTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReservedCapacityTemplateServiceServer).DeleteReservedCapacityTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReservedCapacityTemplateService_DeleteReservedCapacityTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReservedCapacityTemplateServiceServer).DeleteReservedCapacityTemplate(ctx, req.(*DeleteReservedCapacityTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ReservedCapacityTemplateService_ServiceDesc is the grpc.ServiceDesc for ReservedCapacityTemplateService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ReservedCapacityTemplateService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "global.nextgen.v1.ReservedCapacityTemplateService",
	HandlerType: (*ReservedCapacityTemplateServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateReservedCapacityTemplate",
			Handler:    _ReservedCapacityTemplateService_CreateReservedCapacityTemplate_Handler,
		},
		{
			MethodName: "GetReservedCapacityTemplate",
			Handler:    _ReservedCapacityTemplateService_GetReservedCapacityTemplate_Handler,
		},
		{
			MethodName: "ListReservedCapacityTemplates",
			Handler:    _ReservedCapacityTemplateService_ListReservedCapacityTemplates_Handler,
		},
		{
			MethodName: "UpdateReservedCapacityTemplateStatus",
			Handler:    _ReservedCapacityTemplateService_UpdateReservedCapacityTemplateStatus_Handler,
		},
		{
			MethodName: "DeleteReservedCapacityTemplate",
			Handler:    _ReservedCapacityTemplateService_DeleteReservedCapacityTemplate_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "global/nextgen/v1/reserved_capacity_template.proto",
}