// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: payments.proto

package pb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	math "math"
	drpc "storj.io/drpc"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type PrepareInvoiceRecordsRequest struct {
	Period               time.Time `protobuf:"bytes,1,opt,name=period,proto3,stdtime" json:"period"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *PrepareInvoiceRecordsRequest) Reset()         { *m = PrepareInvoiceRecordsRequest{} }
func (m *PrepareInvoiceRecordsRequest) String() string { return proto.CompactTextString(m) }
func (*PrepareInvoiceRecordsRequest) ProtoMessage()    {}
func (*PrepareInvoiceRecordsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{0}
}
func (m *PrepareInvoiceRecordsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrepareInvoiceRecordsRequest.Unmarshal(m, b)
}
func (m *PrepareInvoiceRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrepareInvoiceRecordsRequest.Marshal(b, m, deterministic)
}
func (m *PrepareInvoiceRecordsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrepareInvoiceRecordsRequest.Merge(m, src)
}
func (m *PrepareInvoiceRecordsRequest) XXX_Size() int {
	return xxx_messageInfo_PrepareInvoiceRecordsRequest.Size(m)
}
func (m *PrepareInvoiceRecordsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PrepareInvoiceRecordsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PrepareInvoiceRecordsRequest proto.InternalMessageInfo

func (m *PrepareInvoiceRecordsRequest) GetPeriod() time.Time {
	if m != nil {
		return m.Period
	}
	return time.Time{}
}

type PrepareInvoiceRecordsResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrepareInvoiceRecordsResponse) Reset()         { *m = PrepareInvoiceRecordsResponse{} }
func (m *PrepareInvoiceRecordsResponse) String() string { return proto.CompactTextString(m) }
func (*PrepareInvoiceRecordsResponse) ProtoMessage()    {}
func (*PrepareInvoiceRecordsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{1}
}
func (m *PrepareInvoiceRecordsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrepareInvoiceRecordsResponse.Unmarshal(m, b)
}
func (m *PrepareInvoiceRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrepareInvoiceRecordsResponse.Marshal(b, m, deterministic)
}
func (m *PrepareInvoiceRecordsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrepareInvoiceRecordsResponse.Merge(m, src)
}
func (m *PrepareInvoiceRecordsResponse) XXX_Size() int {
	return xxx_messageInfo_PrepareInvoiceRecordsResponse.Size(m)
}
func (m *PrepareInvoiceRecordsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PrepareInvoiceRecordsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PrepareInvoiceRecordsResponse proto.InternalMessageInfo

type ApplyInvoiceRecordsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplyInvoiceRecordsRequest) Reset()         { *m = ApplyInvoiceRecordsRequest{} }
func (m *ApplyInvoiceRecordsRequest) String() string { return proto.CompactTextString(m) }
func (*ApplyInvoiceRecordsRequest) ProtoMessage()    {}
func (*ApplyInvoiceRecordsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{2}
}
func (m *ApplyInvoiceRecordsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ApplyInvoiceRecordsRequest.Unmarshal(m, b)
}
func (m *ApplyInvoiceRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ApplyInvoiceRecordsRequest.Marshal(b, m, deterministic)
}
func (m *ApplyInvoiceRecordsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplyInvoiceRecordsRequest.Merge(m, src)
}
func (m *ApplyInvoiceRecordsRequest) XXX_Size() int {
	return xxx_messageInfo_ApplyInvoiceRecordsRequest.Size(m)
}
func (m *ApplyInvoiceRecordsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplyInvoiceRecordsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ApplyInvoiceRecordsRequest proto.InternalMessageInfo

type ApplyInvoiceRecordsResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplyInvoiceRecordsResponse) Reset()         { *m = ApplyInvoiceRecordsResponse{} }
func (m *ApplyInvoiceRecordsResponse) String() string { return proto.CompactTextString(m) }
func (*ApplyInvoiceRecordsResponse) ProtoMessage()    {}
func (*ApplyInvoiceRecordsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{3}
}
func (m *ApplyInvoiceRecordsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ApplyInvoiceRecordsResponse.Unmarshal(m, b)
}
func (m *ApplyInvoiceRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ApplyInvoiceRecordsResponse.Marshal(b, m, deterministic)
}
func (m *ApplyInvoiceRecordsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplyInvoiceRecordsResponse.Merge(m, src)
}
func (m *ApplyInvoiceRecordsResponse) XXX_Size() int {
	return xxx_messageInfo_ApplyInvoiceRecordsResponse.Size(m)
}
func (m *ApplyInvoiceRecordsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplyInvoiceRecordsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ApplyInvoiceRecordsResponse proto.InternalMessageInfo

type CreateInvoicesRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateInvoicesRequest) Reset()         { *m = CreateInvoicesRequest{} }
func (m *CreateInvoicesRequest) String() string { return proto.CompactTextString(m) }
func (*CreateInvoicesRequest) ProtoMessage()    {}
func (*CreateInvoicesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{4}
}
func (m *CreateInvoicesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateInvoicesRequest.Unmarshal(m, b)
}
func (m *CreateInvoicesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateInvoicesRequest.Marshal(b, m, deterministic)
}
func (m *CreateInvoicesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateInvoicesRequest.Merge(m, src)
}
func (m *CreateInvoicesRequest) XXX_Size() int {
	return xxx_messageInfo_CreateInvoicesRequest.Size(m)
}
func (m *CreateInvoicesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateInvoicesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateInvoicesRequest proto.InternalMessageInfo

type CreateInvoicesResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateInvoicesResponse) Reset()         { *m = CreateInvoicesResponse{} }
func (m *CreateInvoicesResponse) String() string { return proto.CompactTextString(m) }
func (*CreateInvoicesResponse) ProtoMessage()    {}
func (*CreateInvoicesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_a9566e6e864d2854, []int{5}
}
func (m *CreateInvoicesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateInvoicesResponse.Unmarshal(m, b)
}
func (m *CreateInvoicesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateInvoicesResponse.Marshal(b, m, deterministic)
}
func (m *CreateInvoicesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateInvoicesResponse.Merge(m, src)
}
func (m *CreateInvoicesResponse) XXX_Size() int {
	return xxx_messageInfo_CreateInvoicesResponse.Size(m)
}
func (m *CreateInvoicesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateInvoicesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateInvoicesResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*PrepareInvoiceRecordsRequest)(nil), "nodestats.PrepareInvoiceRecordsRequest")
	proto.RegisterType((*PrepareInvoiceRecordsResponse)(nil), "nodestats.PrepareInvoiceRecordsResponse")
	proto.RegisterType((*ApplyInvoiceRecordsRequest)(nil), "nodestats.ApplyInvoiceRecordsRequest")
	proto.RegisterType((*ApplyInvoiceRecordsResponse)(nil), "nodestats.ApplyInvoiceRecordsResponse")
	proto.RegisterType((*CreateInvoicesRequest)(nil), "nodestats.CreateInvoicesRequest")
	proto.RegisterType((*CreateInvoicesResponse)(nil), "nodestats.CreateInvoicesResponse")
}

func init() { proto.RegisterFile("payments.proto", fileDescriptor_a9566e6e864d2854) }

var fileDescriptor_a9566e6e864d2854 = []byte{
	// 288 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2b, 0x48, 0xac, 0xcc,
	0x4d, 0xcd, 0x2b, 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xcc, 0xcb, 0x4f, 0x49,
	0x2d, 0x2e, 0x49, 0x2c, 0x29, 0x96, 0xe2, 0x4a, 0xcf, 0x4f, 0xcf, 0x87, 0x08, 0x4b, 0xc9, 0xa7,
	0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x83, 0x79, 0x49, 0xa5, 0x69, 0xfa, 0x25, 0x99, 0xb9, 0x20,
	0x65, 0xb9, 0x05, 0x10, 0x05, 0x4a, 0x31, 0x5c, 0x32, 0x01, 0x45, 0xa9, 0x05, 0x89, 0x45, 0xa9,
	0x9e, 0x79, 0x65, 0xf9, 0x99, 0xc9, 0xa9, 0x41, 0xa9, 0xc9, 0xf9, 0x45, 0x29, 0xc5, 0x41, 0xa9,
	0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42, 0x36, 0x5c, 0x6c, 0x05, 0xa9, 0x45, 0x99, 0xf9, 0x29, 0x12,
	0x8c, 0x0a, 0x8c, 0x1a, 0xdc, 0x46, 0x52, 0x7a, 0x10, 0x13, 0xf5, 0x60, 0x26, 0xea, 0x85, 0xc0,
	0x4c, 0x74, 0xe2, 0x38, 0x71, 0x4f, 0x9e, 0x61, 0xc2, 0x7d, 0x79, 0xc6, 0x20, 0xa8, 0x1e, 0x25,
	0x79, 0x2e, 0x59, 0x1c, 0xa6, 0x17, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x2a, 0xc9, 0x70, 0x49, 0x39,
	0x16, 0x14, 0xe4, 0x54, 0x62, 0xb5, 0x5c, 0x49, 0x96, 0x4b, 0x1a, 0xab, 0x2c, 0x54, 0xb3, 0x38,
	0x97, 0xa8, 0x73, 0x51, 0x6a, 0x62, 0x09, 0xcc, 0x70, 0xb8, 0x3e, 0x09, 0x2e, 0x31, 0x74, 0x09,
	0x88, 0x16, 0xa3, 0xcd, 0x4c, 0x5c, 0x1c, 0x01, 0xd0, 0x90, 0x13, 0xca, 0xe2, 0x12, 0xc5, 0xea,
	0x3a, 0x21, 0x75, 0x3d, 0x78, 0x68, 0xea, 0xe1, 0x0b, 0x1d, 0x29, 0x0d, 0xc2, 0x0a, 0x21, 0x16,
	0x0b, 0xa5, 0x70, 0x09, 0x63, 0xf1, 0x8a, 0x90, 0x2a, 0x92, 0x01, 0xb8, 0x03, 0x42, 0x4a, 0x8d,
	0x90, 0x32, 0xa8, 0x2d, 0xa1, 0x5c, 0x7c, 0xa8, 0x1e, 0x17, 0x52, 0x40, 0xd2, 0x89, 0x35, 0xb0,
	0xa4, 0x14, 0xf1, 0xa8, 0x80, 0x18, 0xeb, 0xc4, 0x12, 0xc5, 0x54, 0x90, 0x94, 0xc4, 0x06, 0x8e,
	0x72, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x99, 0xc9, 0xeb, 0xe7, 0x7b, 0x02, 0x00, 0x00,
}

type DRPCPaymentsClient interface {
	DRPCConn() drpc.Conn

	PrepareInvoiceRecords(ctx context.Context, in *PrepareInvoiceRecordsRequest) (*PrepareInvoiceRecordsResponse, error)
	ApplyInvoiceRecords(ctx context.Context, in *ApplyInvoiceRecordsRequest) (*ApplyInvoiceRecordsResponse, error)
	CreateInvoices(ctx context.Context, in *CreateInvoicesRequest) (*CreateInvoicesResponse, error)
}

type drpcPaymentsClient struct {
	cc drpc.Conn
}

func NewDRPCPaymentsClient(cc drpc.Conn) DRPCPaymentsClient {
	return &drpcPaymentsClient{cc}
}

func (c *drpcPaymentsClient) DRPCConn() drpc.Conn { return c.cc }

func (c *drpcPaymentsClient) PrepareInvoiceRecords(ctx context.Context, in *PrepareInvoiceRecordsRequest) (*PrepareInvoiceRecordsResponse, error) {
	out := new(PrepareInvoiceRecordsResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/PrepareInvoiceRecords", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *drpcPaymentsClient) ApplyInvoiceRecords(ctx context.Context, in *ApplyInvoiceRecordsRequest) (*ApplyInvoiceRecordsResponse, error) {
	out := new(ApplyInvoiceRecordsResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/ApplyInvoiceRecords", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *drpcPaymentsClient) CreateInvoices(ctx context.Context, in *CreateInvoicesRequest) (*CreateInvoicesResponse, error) {
	out := new(CreateInvoicesResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/CreateInvoices", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type DRPCPaymentsServer interface {
	PrepareInvoiceRecords(context.Context, *PrepareInvoiceRecordsRequest) (*PrepareInvoiceRecordsResponse, error)
	ApplyInvoiceRecords(context.Context, *ApplyInvoiceRecordsRequest) (*ApplyInvoiceRecordsResponse, error)
	CreateInvoices(context.Context, *CreateInvoicesRequest) (*CreateInvoicesResponse, error)
}

type DRPCPaymentsDescription struct{}

func (DRPCPaymentsDescription) NumMethods() int { return 3 }

func (DRPCPaymentsDescription) Method(n int) (string, drpc.Handler, interface{}, bool) {
	switch n {
	case 0:
		return "/nodestats.Payments/PrepareInvoiceRecords",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCPaymentsServer).
					PrepareInvoiceRecords(
						ctx,
						in1.(*PrepareInvoiceRecordsRequest),
					)
			}, DRPCPaymentsServer.PrepareInvoiceRecords, true
	case 1:
		return "/nodestats.Payments/ApplyInvoiceRecords",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCPaymentsServer).
					ApplyInvoiceRecords(
						ctx,
						in1.(*ApplyInvoiceRecordsRequest),
					)
			}, DRPCPaymentsServer.ApplyInvoiceRecords, true
	case 2:
		return "/nodestats.Payments/CreateInvoices",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCPaymentsServer).
					CreateInvoices(
						ctx,
						in1.(*CreateInvoicesRequest),
					)
			}, DRPCPaymentsServer.CreateInvoices, true
	default:
		return "", nil, nil, false
	}
}

func DRPCRegisterPayments(srv drpc.Server, impl DRPCPaymentsServer) {
	srv.Register(impl, DRPCPaymentsDescription{})
}

type DRPCPayments_PrepareInvoiceRecordsStream interface {
	drpc.Stream
	SendAndClose(*PrepareInvoiceRecordsResponse) error
}

type drpcPaymentsPrepareInvoiceRecordsStream struct {
	drpc.Stream
}

func (x *drpcPaymentsPrepareInvoiceRecordsStream) SendAndClose(m *PrepareInvoiceRecordsResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

type DRPCPayments_ApplyInvoiceRecordsStream interface {
	drpc.Stream
	SendAndClose(*ApplyInvoiceRecordsResponse) error
}

type drpcPaymentsApplyInvoiceRecordsStream struct {
	drpc.Stream
}

func (x *drpcPaymentsApplyInvoiceRecordsStream) SendAndClose(m *ApplyInvoiceRecordsResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

type DRPCPayments_CreateInvoicesStream interface {
	drpc.Stream
	SendAndClose(*CreateInvoicesResponse) error
}

type drpcPaymentsCreateInvoicesStream struct {
	drpc.Stream
}

func (x *drpcPaymentsCreateInvoicesStream) SendAndClose(m *CreateInvoicesResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// PaymentsClient is the client API for Payments service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PaymentsClient interface {
	PrepareInvoiceRecords(ctx context.Context, in *PrepareInvoiceRecordsRequest, opts ...grpc.CallOption) (*PrepareInvoiceRecordsResponse, error)
	ApplyInvoiceRecords(ctx context.Context, in *ApplyInvoiceRecordsRequest, opts ...grpc.CallOption) (*ApplyInvoiceRecordsResponse, error)
	CreateInvoices(ctx context.Context, in *CreateInvoicesRequest, opts ...grpc.CallOption) (*CreateInvoicesResponse, error)
}

type paymentsClient struct {
	cc *grpc.ClientConn
}

func NewPaymentsClient(cc *grpc.ClientConn) PaymentsClient {
	return &paymentsClient{cc}
}

func (c *paymentsClient) PrepareInvoiceRecords(ctx context.Context, in *PrepareInvoiceRecordsRequest, opts ...grpc.CallOption) (*PrepareInvoiceRecordsResponse, error) {
	out := new(PrepareInvoiceRecordsResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/PrepareInvoiceRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *paymentsClient) ApplyInvoiceRecords(ctx context.Context, in *ApplyInvoiceRecordsRequest, opts ...grpc.CallOption) (*ApplyInvoiceRecordsResponse, error) {
	out := new(ApplyInvoiceRecordsResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/ApplyInvoiceRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *paymentsClient) CreateInvoices(ctx context.Context, in *CreateInvoicesRequest, opts ...grpc.CallOption) (*CreateInvoicesResponse, error) {
	out := new(CreateInvoicesResponse)
	err := c.cc.Invoke(ctx, "/nodestats.Payments/CreateInvoices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PaymentsServer is the server API for Payments service.
type PaymentsServer interface {
	PrepareInvoiceRecords(context.Context, *PrepareInvoiceRecordsRequest) (*PrepareInvoiceRecordsResponse, error)
	ApplyInvoiceRecords(context.Context, *ApplyInvoiceRecordsRequest) (*ApplyInvoiceRecordsResponse, error)
	CreateInvoices(context.Context, *CreateInvoicesRequest) (*CreateInvoicesResponse, error)
}

func RegisterPaymentsServer(s *grpc.Server, srv PaymentsServer) {
	s.RegisterService(&_Payments_serviceDesc, srv)
}

func _Payments_PrepareInvoiceRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrepareInvoiceRecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PaymentsServer).PrepareInvoiceRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nodestats.Payments/PrepareInvoiceRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PaymentsServer).PrepareInvoiceRecords(ctx, req.(*PrepareInvoiceRecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Payments_ApplyInvoiceRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyInvoiceRecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PaymentsServer).ApplyInvoiceRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nodestats.Payments/ApplyInvoiceRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PaymentsServer).ApplyInvoiceRecords(ctx, req.(*ApplyInvoiceRecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Payments_CreateInvoices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateInvoicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PaymentsServer).CreateInvoices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nodestats.Payments/CreateInvoices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PaymentsServer).CreateInvoices(ctx, req.(*CreateInvoicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Payments_serviceDesc = grpc.ServiceDesc{
	ServiceName: "nodestats.Payments",
	HandlerType: (*PaymentsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PrepareInvoiceRecords",
			Handler:    _Payments_PrepareInvoiceRecords_Handler,
		},
		{
			MethodName: "ApplyInvoiceRecords",
			Handler:    _Payments_ApplyInvoiceRecords_Handler,
		},
		{
			MethodName: "CreateInvoices",
			Handler:    _Payments_CreateInvoices_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "payments.proto",
}