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

package serverless

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

const (
	ServerlessBillingService_GetAllSpendLimits_FullMethodName        = "/serverless.ServerlessBillingService/GetAllSpendLimits"
	ServerlessBillingService_GetSpendLimit_FullMethodName            = "/serverless.ServerlessBillingService/GetSpendLimit"
	ServerlessBillingService_ModifySpendLimit_FullMethodName         = "/serverless.ServerlessBillingService/ModifySpendLimit"
	ServerlessBillingService_SetSpendLimit_FullMethodName            = "/serverless.ServerlessBillingService/SetSpendLimit"
	ServerlessBillingService_DeleteSpendLimit_FullMethodName         = "/serverless.ServerlessBillingService/DeleteSpendLimit"
	ServerlessBillingService_PredictSpendLimit_FullMethodName        = "/serverless.ServerlessBillingService/PredictSpendLimit"
	ServerlessBillingService_PredictClusterSpendLimit_FullMethodName = "/serverless.ServerlessBillingService/PredictClusterSpendLimit"
	ServerlessBillingService_GetSpendLimitDetails_FullMethodName     = "/serverless.ServerlessBillingService/GetSpendLimitDetails"
	ServerlessBillingService_GetResourceLimitMode_FullMethodName     = "/serverless.ServerlessBillingService/GetResourceLimitMode"
	ServerlessBillingService_GetPricingDetails_FullMethodName        = "/serverless.ServerlessBillingService/GetPricingDetails"
	ServerlessBillingService_SendExpensiveSQLEmail_FullMethodName    = "/serverless.ServerlessBillingService/SendExpensiveSQLEmail"
	ServerlessBillingService_PredictCost_FullMethodName              = "/serverless.ServerlessBillingService/PredictCost"
)

// ServerlessBillingServiceClient is the client API for ServerlessBillingService 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 ServerlessBillingServiceClient interface {
	GetAllSpendLimits(ctx context.Context, in *GetAllSpendLimitsReq, opts ...grpc.CallOption) (*GetAllSpendLimitsResp, error)
	GetSpendLimit(ctx context.Context, in *GetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error)
	ModifySpendLimit(ctx context.Context, in *SetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error)
	SetSpendLimit(ctx context.Context, in *SetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error)
	DeleteSpendLimit(ctx context.Context, in *DeleteSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error)
	PredictSpendLimit(ctx context.Context, in *PredictSpendLimitReq, opts ...grpc.CallOption) (*PredictSpendLimitResp, error)
	PredictClusterSpendLimit(ctx context.Context, in *PredictClusterSpendLimitReq, opts ...grpc.CallOption) (*PredictSpendLimitResp, error)
	GetSpendLimitDetails(ctx context.Context, in *GetSpendLimitDetailsReq, opts ...grpc.CallOption) (*GetSpendLimitDetailsResp, error)
	GetResourceLimitMode(ctx context.Context, in *GetResourceLimitModeReq, opts ...grpc.CallOption) (*GetResourceLimitModeResp, error)
	GetPricingDetails(ctx context.Context, in *GetPricingDetailsReq, opts ...grpc.CallOption) (*GetPricingDetailsResp, error)
	SendExpensiveSQLEmail(ctx context.Context, in *ExpensiveSqlEmailReq, opts ...grpc.CallOption) (*ExpensiveSqlEmailResp, error)
	PredictCost(ctx context.Context, in *PredictCostReq, opts ...grpc.CallOption) (*PredictCostResp, error)
}

type serverlessBillingServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessBillingServiceClient(cc grpc.ClientConnInterface) ServerlessBillingServiceClient {
	return &serverlessBillingServiceClient{cc}
}

func (c *serverlessBillingServiceClient) GetAllSpendLimits(ctx context.Context, in *GetAllSpendLimitsReq, opts ...grpc.CallOption) (*GetAllSpendLimitsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetAllSpendLimitsResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_GetAllSpendLimits_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) GetSpendLimit(ctx context.Context, in *GetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_GetSpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) ModifySpendLimit(ctx context.Context, in *SetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_ModifySpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) SetSpendLimit(ctx context.Context, in *SetSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_SetSpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) DeleteSpendLimit(ctx context.Context, in *DeleteSpendLimitReq, opts ...grpc.CallOption) (*GetSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_DeleteSpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) PredictSpendLimit(ctx context.Context, in *PredictSpendLimitReq, opts ...grpc.CallOption) (*PredictSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PredictSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_PredictSpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) PredictClusterSpendLimit(ctx context.Context, in *PredictClusterSpendLimitReq, opts ...grpc.CallOption) (*PredictSpendLimitResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PredictSpendLimitResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_PredictClusterSpendLimit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) GetSpendLimitDetails(ctx context.Context, in *GetSpendLimitDetailsReq, opts ...grpc.CallOption) (*GetSpendLimitDetailsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSpendLimitDetailsResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_GetSpendLimitDetails_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) GetResourceLimitMode(ctx context.Context, in *GetResourceLimitModeReq, opts ...grpc.CallOption) (*GetResourceLimitModeResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetResourceLimitModeResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_GetResourceLimitMode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) GetPricingDetails(ctx context.Context, in *GetPricingDetailsReq, opts ...grpc.CallOption) (*GetPricingDetailsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetPricingDetailsResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_GetPricingDetails_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) SendExpensiveSQLEmail(ctx context.Context, in *ExpensiveSqlEmailReq, opts ...grpc.CallOption) (*ExpensiveSqlEmailResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExpensiveSqlEmailResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_SendExpensiveSQLEmail_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBillingServiceClient) PredictCost(ctx context.Context, in *PredictCostReq, opts ...grpc.CallOption) (*PredictCostResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PredictCostResp)
	err := c.cc.Invoke(ctx, ServerlessBillingService_PredictCost_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessBillingServiceServer is the server API for ServerlessBillingService service.
// All implementations must embed UnimplementedServerlessBillingServiceServer
// for forward compatibility
type ServerlessBillingServiceServer interface {
	GetAllSpendLimits(context.Context, *GetAllSpendLimitsReq) (*GetAllSpendLimitsResp, error)
	GetSpendLimit(context.Context, *GetSpendLimitReq) (*GetSpendLimitResp, error)
	ModifySpendLimit(context.Context, *SetSpendLimitReq) (*GetSpendLimitResp, error)
	SetSpendLimit(context.Context, *SetSpendLimitReq) (*GetSpendLimitResp, error)
	DeleteSpendLimit(context.Context, *DeleteSpendLimitReq) (*GetSpendLimitResp, error)
	PredictSpendLimit(context.Context, *PredictSpendLimitReq) (*PredictSpendLimitResp, error)
	PredictClusterSpendLimit(context.Context, *PredictClusterSpendLimitReq) (*PredictSpendLimitResp, error)
	GetSpendLimitDetails(context.Context, *GetSpendLimitDetailsReq) (*GetSpendLimitDetailsResp, error)
	GetResourceLimitMode(context.Context, *GetResourceLimitModeReq) (*GetResourceLimitModeResp, error)
	GetPricingDetails(context.Context, *GetPricingDetailsReq) (*GetPricingDetailsResp, error)
	SendExpensiveSQLEmail(context.Context, *ExpensiveSqlEmailReq) (*ExpensiveSqlEmailResp, error)
	PredictCost(context.Context, *PredictCostReq) (*PredictCostResp, error)
	mustEmbedUnimplementedServerlessBillingServiceServer()
}

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

func (UnimplementedServerlessBillingServiceServer) GetAllSpendLimits(context.Context, *GetAllSpendLimitsReq) (*GetAllSpendLimitsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllSpendLimits not implemented")
}
func (UnimplementedServerlessBillingServiceServer) GetSpendLimit(context.Context, *GetSpendLimitReq) (*GetSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) ModifySpendLimit(context.Context, *SetSpendLimitReq) (*GetSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifySpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) SetSpendLimit(context.Context, *SetSpendLimitReq) (*GetSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) DeleteSpendLimit(context.Context, *DeleteSpendLimitReq) (*GetSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) PredictSpendLimit(context.Context, *PredictSpendLimitReq) (*PredictSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PredictSpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) PredictClusterSpendLimit(context.Context, *PredictClusterSpendLimitReq) (*PredictSpendLimitResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PredictClusterSpendLimit not implemented")
}
func (UnimplementedServerlessBillingServiceServer) GetSpendLimitDetails(context.Context, *GetSpendLimitDetailsReq) (*GetSpendLimitDetailsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSpendLimitDetails not implemented")
}
func (UnimplementedServerlessBillingServiceServer) GetResourceLimitMode(context.Context, *GetResourceLimitModeReq) (*GetResourceLimitModeResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetResourceLimitMode not implemented")
}
func (UnimplementedServerlessBillingServiceServer) GetPricingDetails(context.Context, *GetPricingDetailsReq) (*GetPricingDetailsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPricingDetails not implemented")
}
func (UnimplementedServerlessBillingServiceServer) SendExpensiveSQLEmail(context.Context, *ExpensiveSqlEmailReq) (*ExpensiveSqlEmailResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendExpensiveSQLEmail not implemented")
}
func (UnimplementedServerlessBillingServiceServer) PredictCost(context.Context, *PredictCostReq) (*PredictCostResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PredictCost not implemented")
}
func (UnimplementedServerlessBillingServiceServer) mustEmbedUnimplementedServerlessBillingServiceServer() {
}

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

func RegisterServerlessBillingServiceServer(s grpc.ServiceRegistrar, srv ServerlessBillingServiceServer) {
	s.RegisterService(&ServerlessBillingService_ServiceDesc, srv)
}

func _ServerlessBillingService_GetAllSpendLimits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAllSpendLimitsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).GetAllSpendLimits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_GetAllSpendLimits_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).GetAllSpendLimits(ctx, req.(*GetAllSpendLimitsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_GetSpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).GetSpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_GetSpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).GetSpendLimit(ctx, req.(*GetSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_ModifySpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).ModifySpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_ModifySpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).ModifySpendLimit(ctx, req.(*SetSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_SetSpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).SetSpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_SetSpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).SetSpendLimit(ctx, req.(*SetSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_DeleteSpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).DeleteSpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_DeleteSpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).DeleteSpendLimit(ctx, req.(*DeleteSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_PredictSpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PredictSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).PredictSpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_PredictSpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).PredictSpendLimit(ctx, req.(*PredictSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_PredictClusterSpendLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PredictClusterSpendLimitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).PredictClusterSpendLimit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_PredictClusterSpendLimit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).PredictClusterSpendLimit(ctx, req.(*PredictClusterSpendLimitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_GetSpendLimitDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSpendLimitDetailsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).GetSpendLimitDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_GetSpendLimitDetails_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).GetSpendLimitDetails(ctx, req.(*GetSpendLimitDetailsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_GetResourceLimitMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetResourceLimitModeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).GetResourceLimitMode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_GetResourceLimitMode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).GetResourceLimitMode(ctx, req.(*GetResourceLimitModeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_GetPricingDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPricingDetailsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).GetPricingDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_GetPricingDetails_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).GetPricingDetails(ctx, req.(*GetPricingDetailsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_SendExpensiveSQLEmail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExpensiveSqlEmailReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).SendExpensiveSQLEmail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_SendExpensiveSQLEmail_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).SendExpensiveSQLEmail(ctx, req.(*ExpensiveSqlEmailReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBillingService_PredictCost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PredictCostReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBillingServiceServer).PredictCost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBillingService_PredictCost_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBillingServiceServer).PredictCost(ctx, req.(*PredictCostReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessBillingService_ServiceDesc is the grpc.ServiceDesc for ServerlessBillingService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessBillingService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "serverless.ServerlessBillingService",
	HandlerType: (*ServerlessBillingServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAllSpendLimits",
			Handler:    _ServerlessBillingService_GetAllSpendLimits_Handler,
		},
		{
			MethodName: "GetSpendLimit",
			Handler:    _ServerlessBillingService_GetSpendLimit_Handler,
		},
		{
			MethodName: "ModifySpendLimit",
			Handler:    _ServerlessBillingService_ModifySpendLimit_Handler,
		},
		{
			MethodName: "SetSpendLimit",
			Handler:    _ServerlessBillingService_SetSpendLimit_Handler,
		},
		{
			MethodName: "DeleteSpendLimit",
			Handler:    _ServerlessBillingService_DeleteSpendLimit_Handler,
		},
		{
			MethodName: "PredictSpendLimit",
			Handler:    _ServerlessBillingService_PredictSpendLimit_Handler,
		},
		{
			MethodName: "PredictClusterSpendLimit",
			Handler:    _ServerlessBillingService_PredictClusterSpendLimit_Handler,
		},
		{
			MethodName: "GetSpendLimitDetails",
			Handler:    _ServerlessBillingService_GetSpendLimitDetails_Handler,
		},
		{
			MethodName: "GetResourceLimitMode",
			Handler:    _ServerlessBillingService_GetResourceLimitMode_Handler,
		},
		{
			MethodName: "GetPricingDetails",
			Handler:    _ServerlessBillingService_GetPricingDetails_Handler,
		},
		{
			MethodName: "SendExpensiveSQLEmail",
			Handler:    _ServerlessBillingService_SendExpensiveSQLEmail_Handler,
		},
		{
			MethodName: "PredictCost",
			Handler:    _ServerlessBillingService_PredictCost_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "serverless/billing.proto",
}