billing.pb.go

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

package ccloud

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/confluentinc/proto-go-setter"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
)

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

// 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 GetPriceTableReply struct {
	PriceTable           *PriceTable `protobuf:"bytes,1,opt,name=price_table,json=priceTable,proto3" json:"price_table,omitempty" db:"price_table,omitempty" url:"price_table,omitempty"`
	Error                *Error      `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetPriceTableReply) Reset()         { *m = GetPriceTableReply{} }
func (m *GetPriceTableReply) String() string { return proto.CompactTextString(m) }
func (*GetPriceTableReply) ProtoMessage()    {}
func (*GetPriceTableReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{0}
}
func (m *GetPriceTableReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPriceTableReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPriceTableReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetPriceTableReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPriceTableReply.Merge(m, src)
}
func (m *GetPriceTableReply) XXX_Size() int {
	return m.Size()
}
func (m *GetPriceTableReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPriceTableReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetPriceTableReply proto.InternalMessageInfo

func (m *GetPriceTableReply) GetPriceTable() *PriceTable {
	if m != nil {
		return m.PriceTable
	}
	return nil
}

func (m *GetPriceTableReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

// promo code api object for users
type ClaimPromoCodeRequest struct {
	OrgId                int32             `protobuf:"varint,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty" db:"org_id,omitempty" url:"org_id,omitempty"`
	Code                 string            `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty" db:"code,omitempty" url:"code,omitempty"`
	ClaimedBy            int32             `protobuf:"varint,3,opt,name=claimed_by,json=claimedBy,proto3" json:"claimed_by,omitempty" db:"claimed_by,omitempty" url:"claimed_by,omitempty"`
	RequestCarrier       map[string]string `protobuf:"bytes,4,rep,name=request_carrier,json=requestCarrier,proto3" json:"request_carrier,omitempty" redact:"-" db:"request_carrier,omitempty" url:"request_carrier,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ClaimPromoCodeRequest) Reset()         { *m = ClaimPromoCodeRequest{} }
func (m *ClaimPromoCodeRequest) String() string { return proto.CompactTextString(m) }
func (*ClaimPromoCodeRequest) ProtoMessage()    {}
func (*ClaimPromoCodeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{1}
}
func (m *ClaimPromoCodeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClaimPromoCodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClaimPromoCodeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ClaimPromoCodeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClaimPromoCodeRequest.Merge(m, src)
}
func (m *ClaimPromoCodeRequest) XXX_Size() int {
	return m.Size()
}
func (m *ClaimPromoCodeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ClaimPromoCodeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ClaimPromoCodeRequest proto.InternalMessageInfo

func (m *ClaimPromoCodeRequest) GetOrgId() int32 {
	if m != nil {
		return m.OrgId
	}
	return 0
}

func (m *ClaimPromoCodeRequest) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *ClaimPromoCodeRequest) GetClaimedBy() int32 {
	if m != nil {
		return m.ClaimedBy
	}
	return 0
}

func (m *ClaimPromoCodeRequest) GetRequestCarrier() map[string]string {
	if m != nil {
		return m.RequestCarrier
	}
	return nil
}

type ClaimPromoCodeReply struct {
	Claim                *PromoCodeClaim `protobuf:"bytes,1,opt,name=claim,proto3" json:"claim,omitempty" db:"claim,omitempty" url:"claim,omitempty"`
	Error                *Error          `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ClaimPromoCodeReply) Reset()         { *m = ClaimPromoCodeReply{} }
func (m *ClaimPromoCodeReply) String() string { return proto.CompactTextString(m) }
func (*ClaimPromoCodeReply) ProtoMessage()    {}
func (*ClaimPromoCodeReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{2}
}
func (m *ClaimPromoCodeReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClaimPromoCodeReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClaimPromoCodeReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ClaimPromoCodeReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClaimPromoCodeReply.Merge(m, src)
}
func (m *ClaimPromoCodeReply) XXX_Size() int {
	return m.Size()
}
func (m *ClaimPromoCodeReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ClaimPromoCodeReply.DiscardUnknown(m)
}

var xxx_messageInfo_ClaimPromoCodeReply proto.InternalMessageInfo

func (m *ClaimPromoCodeReply) GetClaim() *PromoCodeClaim {
	if m != nil {
		return m.Claim
	}
	return nil
}

func (m *ClaimPromoCodeReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type GetPromoCodeClaimsRequest struct {
	OrgId                int32             `protobuf:"varint,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty" db:"org_id,omitempty" url:"org_id,omitempty"`
	RequestCarrier       map[string]string `protobuf:"bytes,2,rep,name=request_carrier,json=requestCarrier,proto3" json:"request_carrier,omitempty" redact:"-" db:"request_carrier,omitempty" url:"request_carrier,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ExcludeExpired       bool              `protobuf:"varint,3,opt,name=exclude_expired,json=excludeExpired,proto3" json:"exclude_expired,omitempty" db:"exclude_expired,omitempty" url:"exclude_expired,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GetPromoCodeClaimsRequest) Reset()         { *m = GetPromoCodeClaimsRequest{} }
func (m *GetPromoCodeClaimsRequest) String() string { return proto.CompactTextString(m) }
func (*GetPromoCodeClaimsRequest) ProtoMessage()    {}
func (*GetPromoCodeClaimsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{3}
}
func (m *GetPromoCodeClaimsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPromoCodeClaimsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPromoCodeClaimsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetPromoCodeClaimsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPromoCodeClaimsRequest.Merge(m, src)
}
func (m *GetPromoCodeClaimsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetPromoCodeClaimsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPromoCodeClaimsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetPromoCodeClaimsRequest proto.InternalMessageInfo

func (m *GetPromoCodeClaimsRequest) GetOrgId() int32 {
	if m != nil {
		return m.OrgId
	}
	return 0
}

func (m *GetPromoCodeClaimsRequest) GetRequestCarrier() map[string]string {
	if m != nil {
		return m.RequestCarrier
	}
	return nil
}

func (m *GetPromoCodeClaimsRequest) GetExcludeExpired() bool {
	if m != nil {
		return m.ExcludeExpired
	}
	return false
}

type GetPromoCodeClaimsReply struct {
	Claims               []*PromoCodeClaim `protobuf:"bytes,1,rep,name=claims,proto3" json:"claims,omitempty" db:"claims,omitempty" url:"claims,omitempty"`
	Error                *Error            `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GetPromoCodeClaimsReply) Reset()         { *m = GetPromoCodeClaimsReply{} }
func (m *GetPromoCodeClaimsReply) String() string { return proto.CompactTextString(m) }
func (*GetPromoCodeClaimsReply) ProtoMessage()    {}
func (*GetPromoCodeClaimsReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{4}
}
func (m *GetPromoCodeClaimsReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPromoCodeClaimsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPromoCodeClaimsReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetPromoCodeClaimsReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPromoCodeClaimsReply.Merge(m, src)
}
func (m *GetPromoCodeClaimsReply) XXX_Size() int {
	return m.Size()
}
func (m *GetPromoCodeClaimsReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPromoCodeClaimsReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetPromoCodeClaimsReply proto.InternalMessageInfo

func (m *GetPromoCodeClaimsReply) GetClaims() []*PromoCodeClaim {
	if m != nil {
		return m.Claims
	}
	return nil
}

func (m *GetPromoCodeClaimsReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type PromoCodeClaim struct {
	OrgId                int32            `protobuf:"varint,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty" db:"org_id,omitempty" url:"org_id,omitempty"`
	Code                 string           `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty" db:"code,omitempty" url:"code,omitempty"`
	Amount               int64            `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty" db:"amount,omitempty" url:"amount,omitempty"`
	Balance              int64            `protobuf:"varint,4,opt,name=balance,proto3" json:"balance,omitempty" db:"balance,omitempty" url:"balance,omitempty"`
	ClaimDate            *types.Timestamp `protobuf:"bytes,5,opt,name=claim_date,json=claimDate,proto3" json:"claim_date,omitempty" db:"claim_date,omitempty" url:"claim_date,omitempty"`
	CreditExpirationDate *types.Timestamp `protobuf:"bytes,6,opt,name=credit_expiration_date,json=creditExpirationDate,proto3" json:"credit_expiration_date,omitempty" db:"credit_expiration_date,omitempty" url:"credit_expiration_date,omitempty"`
	ClaimedBy            int32            `protobuf:"varint,7,opt,name=claimed_by,json=claimedBy,proto3" json:"claimed_by,omitempty" db:"claimed_by,omitempty" url:"claimed_by,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *PromoCodeClaim) Reset()         { *m = PromoCodeClaim{} }
func (m *PromoCodeClaim) String() string { return proto.CompactTextString(m) }
func (*PromoCodeClaim) ProtoMessage()    {}
func (*PromoCodeClaim) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{5}
}
func (m *PromoCodeClaim) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PromoCodeClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PromoCodeClaim.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PromoCodeClaim) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PromoCodeClaim.Merge(m, src)
}
func (m *PromoCodeClaim) XXX_Size() int {
	return m.Size()
}
func (m *PromoCodeClaim) XXX_DiscardUnknown() {
	xxx_messageInfo_PromoCodeClaim.DiscardUnknown(m)
}

var xxx_messageInfo_PromoCodeClaim proto.InternalMessageInfo

func (m *PromoCodeClaim) GetOrgId() int32 {
	if m != nil {
		return m.OrgId
	}
	return 0
}

func (m *PromoCodeClaim) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *PromoCodeClaim) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *PromoCodeClaim) GetBalance() int64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (m *PromoCodeClaim) GetClaimDate() *types.Timestamp {
	if m != nil {
		return m.ClaimDate
	}
	return nil
}

func (m *PromoCodeClaim) GetCreditExpirationDate() *types.Timestamp {
	if m != nil {
		return m.CreditExpirationDate
	}
	return nil
}

func (m *PromoCodeClaim) GetClaimedBy() int32 {
	if m != nil {
		return m.ClaimedBy
	}
	return 0
}

type PriceTable struct {
	PriceTable           map[string]*UnitPrices `protobuf:"bytes,1,rep,name=price_table,json=priceTable,proto3" json:"price_table,omitempty" db:"price_table,omitempty" url:"price_table,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *PriceTable) Reset()         { *m = PriceTable{} }
func (m *PriceTable) String() string { return proto.CompactTextString(m) }
func (*PriceTable) ProtoMessage()    {}
func (*PriceTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{6}
}
func (m *PriceTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceTable.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceTable.Merge(m, src)
}
func (m *PriceTable) XXX_Size() int {
	return m.Size()
}
func (m *PriceTable) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceTable.DiscardUnknown(m)
}

var xxx_messageInfo_PriceTable proto.InternalMessageInfo

func (m *PriceTable) GetPriceTable() map[string]*UnitPrices {
	if m != nil {
		return m.PriceTable
	}
	return nil
}

type UnitPrices struct {
	Prices               map[string]float64 `protobuf:"bytes,1,rep,name=prices,proto3" json:"prices,omitempty" db:"prices,omitempty" url:"prices,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	Unit                 string             `protobuf:"bytes,2,opt,name=unit,proto3" json:"unit,omitempty" db:"unit,omitempty" url:"unit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *UnitPrices) Reset()         { *m = UnitPrices{} }
func (m *UnitPrices) String() string { return proto.CompactTextString(m) }
func (*UnitPrices) ProtoMessage()    {}
func (*UnitPrices) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{7}
}
func (m *UnitPrices) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnitPrices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnitPrices.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnitPrices) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnitPrices.Merge(m, src)
}
func (m *UnitPrices) XXX_Size() int {
	return m.Size()
}
func (m *UnitPrices) XXX_DiscardUnknown() {
	xxx_messageInfo_UnitPrices.DiscardUnknown(m)
}

var xxx_messageInfo_UnitPrices proto.InternalMessageInfo

func (m *UnitPrices) GetPrices() map[string]float64 {
	if m != nil {
		return m.Prices
	}
	return nil
}

func (m *UnitPrices) GetUnit() string {
	if m != nil {
		return m.Unit
	}
	return ""
}

type Card struct {
	Cardholder           string   `protobuf:"bytes,1,opt,name=cardholder,proto3" json:"cardholder,omitempty" db:"cardholder,omitempty" url:"cardholder,omitempty"`
	Brand                string   `protobuf:"bytes,2,opt,name=brand,proto3" json:"brand,omitempty" db:"brand,omitempty" url:"brand,omitempty"`
	Last4                string   `protobuf:"bytes,3,opt,name=last4,proto3" json:"last4,omitempty" db:"last4,omitempty" url:"last4,omitempty"`
	ExpMonth             string   `protobuf:"bytes,4,opt,name=exp_month,json=expMonth,proto3" json:"exp_month,omitempty" db:"exp_month,omitempty" url:"exp_month,omitempty"`
	ExpYear              string   `protobuf:"bytes,5,opt,name=exp_year,json=expYear,proto3" json:"exp_year,omitempty" db:"exp_year,omitempty" url:"exp_year,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Card) Reset()         { *m = Card{} }
func (m *Card) String() string { return proto.CompactTextString(m) }
func (*Card) ProtoMessage()    {}
func (*Card) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{8}
}
func (m *Card) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Card) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Card.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Card) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Card.Merge(m, src)
}
func (m *Card) XXX_Size() int {
	return m.Size()
}
func (m *Card) XXX_DiscardUnknown() {
	xxx_messageInfo_Card.DiscardUnknown(m)
}

var xxx_messageInfo_Card proto.InternalMessageInfo

func (m *Card) GetCardholder() string {
	if m != nil {
		return m.Cardholder
	}
	return ""
}

func (m *Card) GetBrand() string {
	if m != nil {
		return m.Brand
	}
	return ""
}

func (m *Card) GetLast4() string {
	if m != nil {
		return m.Last4
	}
	return ""
}

func (m *Card) GetExpMonth() string {
	if m != nil {
		return m.ExpMonth
	}
	return ""
}

func (m *Card) GetExpYear() string {
	if m != nil {
		return m.ExpYear
	}
	return ""
}

type GetPaymentInfoReply struct {
	Card                 *Card         `protobuf:"bytes,1,opt,name=card,proto3" json:"card,omitempty" db:"card,omitempty" url:"card,omitempty"`
	Organization         *Organization `protobuf:"bytes,3,opt,name=organization,proto3" json:"organization,omitempty" db:"organization,omitempty" url:"organization,omitempty"`
	Error                *Error        `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	TaxAddress           *TaxAddress   `protobuf:"bytes,4,opt,name=tax_address,json=taxAddress,proto3" json:"tax_address,omitempty" db:"tax_address,omitempty" url:"tax_address,omitempty"`
	TaxIds               []*TaxId      `protobuf:"bytes,5,rep,name=tax_ids,json=taxIds,proto3" json:"tax_ids,omitempty" db:"tax_ids,omitempty" url:"tax_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GetPaymentInfoReply) Reset()         { *m = GetPaymentInfoReply{} }
func (m *GetPaymentInfoReply) String() string { return proto.CompactTextString(m) }
func (*GetPaymentInfoReply) ProtoMessage()    {}
func (*GetPaymentInfoReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{9}
}
func (m *GetPaymentInfoReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPaymentInfoReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPaymentInfoReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetPaymentInfoReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPaymentInfoReply.Merge(m, src)
}
func (m *GetPaymentInfoReply) XXX_Size() int {
	return m.Size()
}
func (m *GetPaymentInfoReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPaymentInfoReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetPaymentInfoReply proto.InternalMessageInfo

func (m *GetPaymentInfoReply) GetCard() *Card {
	if m != nil {
		return m.Card
	}
	return nil
}

func (m *GetPaymentInfoReply) GetOrganization() *Organization {
	if m != nil {
		return m.Organization
	}
	return nil
}

func (m *GetPaymentInfoReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *GetPaymentInfoReply) GetTaxAddress() *TaxAddress {
	if m != nil {
		return m.TaxAddress
	}
	return nil
}

func (m *GetPaymentInfoReply) GetTaxIds() []*TaxId {
	if m != nil {
		return m.TaxIds
	}
	return nil
}

type UpdatePaymentInfoRequest struct {
	StripeToken          string            `protobuf:"bytes,1,opt,name=stripe_token,json=stripeToken,proto3" json:"stripe_token,omitempty" redact:"-" db:"stripe_token,omitempty" url:"stripe_token,omitempty"`
	Organization         *Organization     `protobuf:"bytes,2,opt,name=organization,proto3" json:"organization,omitempty" db:"organization,omitempty" url:"organization,omitempty"`
	RequestCarrier       map[string]string `protobuf:"bytes,3,rep,name=request_carrier,json=requestCarrier,proto3" json:"request_carrier,omitempty" redact:"-" db:"request_carrier,omitempty" url:"request_carrier,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *UpdatePaymentInfoRequest) Reset()         { *m = UpdatePaymentInfoRequest{} }
func (m *UpdatePaymentInfoRequest) String() string { return proto.CompactTextString(m) }
func (*UpdatePaymentInfoRequest) ProtoMessage()    {}
func (*UpdatePaymentInfoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{10}
}
func (m *UpdatePaymentInfoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdatePaymentInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdatePaymentInfoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdatePaymentInfoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdatePaymentInfoRequest.Merge(m, src)
}
func (m *UpdatePaymentInfoRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdatePaymentInfoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdatePaymentInfoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdatePaymentInfoRequest proto.InternalMessageInfo

func (m *UpdatePaymentInfoRequest) GetStripeToken() string {
	if m != nil {
		return m.StripeToken
	}
	return ""
}

func (m *UpdatePaymentInfoRequest) GetOrganization() *Organization {
	if m != nil {
		return m.Organization
	}
	return nil
}

func (m *UpdatePaymentInfoRequest) GetRequestCarrier() map[string]string {
	if m != nil {
		return m.RequestCarrier
	}
	return nil
}

type UpdatePaymentInfoReply struct {
	Card                 *Card         `protobuf:"bytes,1,opt,name=card,proto3" json:"card,omitempty" db:"card,omitempty" url:"card,omitempty"`
	Organization         *Organization `protobuf:"bytes,3,opt,name=organization,proto3" json:"organization,omitempty" db:"organization,omitempty" url:"organization,omitempty"`
	Error                *Error        `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *UpdatePaymentInfoReply) Reset()         { *m = UpdatePaymentInfoReply{} }
func (m *UpdatePaymentInfoReply) String() string { return proto.CompactTextString(m) }
func (*UpdatePaymentInfoReply) ProtoMessage()    {}
func (*UpdatePaymentInfoReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{11}
}
func (m *UpdatePaymentInfoReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdatePaymentInfoReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdatePaymentInfoReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdatePaymentInfoReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdatePaymentInfoReply.Merge(m, src)
}
func (m *UpdatePaymentInfoReply) XXX_Size() int {
	return m.Size()
}
func (m *UpdatePaymentInfoReply) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdatePaymentInfoReply.DiscardUnknown(m)
}

var xxx_messageInfo_UpdatePaymentInfoReply proto.InternalMessageInfo

func (m *UpdatePaymentInfoReply) GetCard() *Card {
	if m != nil {
		return m.Card
	}
	return nil
}

func (m *UpdatePaymentInfoReply) GetOrganization() *Organization {
	if m != nil {
		return m.Organization
	}
	return nil
}

func (m *UpdatePaymentInfoReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type TaxAddress struct {
	Line1 string `protobuf:"bytes,1,opt,name=line1,proto3" json:"line1,omitempty" db:"line1,omitempty" url:"line1,omitempty"`
	Line2 string `protobuf:"bytes,2,opt,name=line2,proto3" json:"line2,omitempty" db:"line2,omitempty" url:"line2,omitempty"`
	City  string `protobuf:"bytes,3,opt,name=city,proto3" json:"city,omitempty" db:"city,omitempty" url:"city,omitempty"`
	State string `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty" db:"state,omitempty" url:"state,omitempty"`
	// country must follow the ISO 3166-1 alpha-2 standard
	// https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
	Country              string   `protobuf:"bytes,5,opt,name=country,proto3" json:"country,omitempty" db:"country,omitempty" url:"country,omitempty"`
	PostalCode           string   `protobuf:"bytes,6,opt,name=postal_code,json=postalCode,proto3" json:"postal_code,omitempty" db:"postal_code,omitempty" url:"postal_code,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaxAddress) Reset()         { *m = TaxAddress{} }
func (m *TaxAddress) String() string { return proto.CompactTextString(m) }
func (*TaxAddress) ProtoMessage()    {}
func (*TaxAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{12}
}
func (m *TaxAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaxAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaxAddress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TaxAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaxAddress.Merge(m, src)
}
func (m *TaxAddress) XXX_Size() int {
	return m.Size()
}
func (m *TaxAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_TaxAddress.DiscardUnknown(m)
}

var xxx_messageInfo_TaxAddress proto.InternalMessageInfo

func (m *TaxAddress) GetLine1() string {
	if m != nil {
		return m.Line1
	}
	return ""
}

func (m *TaxAddress) GetLine2() string {
	if m != nil {
		return m.Line2
	}
	return ""
}

func (m *TaxAddress) GetCity() string {
	if m != nil {
		return m.City
	}
	return ""
}

func (m *TaxAddress) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *TaxAddress) GetCountry() string {
	if m != nil {
		return m.Country
	}
	return ""
}

func (m *TaxAddress) GetPostalCode() string {
	if m != nil {
		return m.PostalCode
	}
	return ""
}

type TaxId struct {
	// details of taxId definition is here:
	// https://stripe.com/docs/api/customer_tax_ids/object
	TypeEnum             string   `protobuf:"bytes,1,opt,name=type_enum,json=typeEnum,proto3" json:"type_enum,omitempty" db:"type_enum,omitempty" url:"type_enum,omitempty"`
	TaxId                string   `protobuf:"bytes,2,opt,name=tax_id,json=taxId,proto3" json:"tax_id,omitempty" db:"tax_id,omitempty" url:"tax_id,omitempty"`
	StripeObjectId       string   `protobuf:"bytes,3,opt,name=stripe_object_id,json=stripeObjectId,proto3" json:"stripe_object_id,omitempty" redact:"-" db:"stripe_object_id,omitempty" url:"stripe_object_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaxId) Reset()         { *m = TaxId{} }
func (m *TaxId) String() string { return proto.CompactTextString(m) }
func (*TaxId) ProtoMessage()    {}
func (*TaxId) Descriptor() ([]byte, []int) {
	return fileDescriptor_76f8da37d8b92239, []int{13}
}
func (m *TaxId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaxId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaxId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TaxId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaxId.Merge(m, src)
}
func (m *TaxId) XXX_Size() int {
	return m.Size()
}
func (m *TaxId) XXX_DiscardUnknown() {
	xxx_messageInfo_TaxId.DiscardUnknown(m)
}

var xxx_messageInfo_TaxId proto.InternalMessageInfo

func (m *TaxId) GetTypeEnum() string {
	if m != nil {
		return m.TypeEnum
	}
	return ""
}

func (m *TaxId) GetTaxId() string {
	if m != nil {
		return m.TaxId
	}
	return ""
}

func (m *TaxId) GetStripeObjectId() string {
	if m != nil {
		return m.StripeObjectId
	}
	return ""
}

func init() {
	proto.RegisterType((*GetPriceTableReply)(nil), "ccloud.billing.GetPriceTableReply")
	proto.RegisterType((*ClaimPromoCodeRequest)(nil), "ccloud.billing.ClaimPromoCodeRequest")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.billing.ClaimPromoCodeRequest.RequestCarrierEntry")
	proto.RegisterType((*ClaimPromoCodeReply)(nil), "ccloud.billing.ClaimPromoCodeReply")
	proto.RegisterType((*GetPromoCodeClaimsRequest)(nil), "ccloud.billing.GetPromoCodeClaimsRequest")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.billing.GetPromoCodeClaimsRequest.RequestCarrierEntry")
	proto.RegisterType((*GetPromoCodeClaimsReply)(nil), "ccloud.billing.GetPromoCodeClaimsReply")
	proto.RegisterType((*PromoCodeClaim)(nil), "ccloud.billing.PromoCodeClaim")
	proto.RegisterType((*PriceTable)(nil), "ccloud.billing.PriceTable")
	proto.RegisterMapType((map[string]*UnitPrices)(nil), "ccloud.billing.PriceTable.PriceTableEntry")
	proto.RegisterType((*UnitPrices)(nil), "ccloud.billing.UnitPrices")
	proto.RegisterMapType((map[string]float64)(nil), "ccloud.billing.UnitPrices.PricesEntry")
	proto.RegisterType((*Card)(nil), "ccloud.billing.Card")
	proto.RegisterType((*GetPaymentInfoReply)(nil), "ccloud.billing.GetPaymentInfoReply")
	proto.RegisterType((*UpdatePaymentInfoRequest)(nil), "ccloud.billing.UpdatePaymentInfoRequest")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.billing.UpdatePaymentInfoRequest.RequestCarrierEntry")
	proto.RegisterType((*UpdatePaymentInfoReply)(nil), "ccloud.billing.UpdatePaymentInfoReply")
	proto.RegisterType((*TaxAddress)(nil), "ccloud.billing.TaxAddress")
	proto.RegisterType((*TaxId)(nil), "ccloud.billing.TaxId")
}

func init() { proto.RegisterFile("billing/billing.proto", fileDescriptor_76f8da37d8b92239) }

var fileDescriptor_76f8da37d8b92239 = []byte{
	// 1538 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0xcd, 0x6f, 0x1b, 0x45,
	0x14, 0xd7, 0x3a, 0xb6, 0xd3, 0x4c, 0x4a, 0x5a, 0x6d, 0x3f, 0x30, 0x39, 0x64, 0x23, 0x1f, 0xaa,
	0xaa, 0x24, 0x76, 0x6b, 0xaa, 0xaa, 0x84, 0x82, 0xc0, 0x69, 0x54, 0x22, 0x8a, 0x12, 0x86, 0x14,
	0x0a, 0x1c, 0xcc, 0x78, 0x77, 0xe2, 0x6c, 0xb3, 0xde, 0x59, 0x66, 0xc7, 0xc5, 0xee, 0x3f, 0xc0,
	0x1d, 0x89, 0x23, 0x52, 0xc5, 0x81, 0x1b, 0x47, 0x24, 0xf8, 0x07, 0x10, 0x12, 0x12, 0x42, 0x42,
	0x48, 0x5c, 0xba, 0x42, 0xbd, 0x70, 0x45, 0x7b, 0xe4, 0x84, 0xe6, 0xc3, 0x6b, 0xef, 0xce, 0x58,
	0x15, 0x6a, 0x0a, 0x3d, 0xf4, 0x14, 0xe7, 0xf7, 0xe6, 0xfd, 0xde, 0xdb, 0xf7, 0xe6, 0x7d, 0x0c,
	0x38, 0xd3, 0xf5, 0x83, 0xc0, 0x0f, 0x7b, 0x4d, 0xf5, 0xb7, 0x11, 0x51, 0xc2, 0x88, 0xbd, 0xe4,
	0xba, 0x01, 0x19, 0x78, 0x0d, 0x85, 0x2e, 0x9f, 0xee, 0x91, 0x1e, 0x11, 0xa2, 0x26, 0xff, 0x25,
	0x4f, 0x2d, 0x3b, 0x3d, 0x42, 0x7a, 0x01, 0x6e, 0x8a, 0xff, 0xba, 0x83, 0xfd, 0x26, 0xf3, 0xfb,
	0x38, 0x66, 0xa8, 0x1f, 0xa9, 0x03, 0x27, 0x5d, 0x42, 0x71, 0x13, 0x53, 0x4a, 0xa8, 0x42, 0x9e,
	0x23, 0xb4, 0xd7, 0x24, 0x54, 0xd9, 0x59, 0x3e, 0x1e, 0x63, 0xc6, 0xb0, 0x12, 0xd6, 0xff, 0xb4,
	0x80, 0x7d, 0x03, 0xb3, 0x5d, 0xea, 0xbb, 0x78, 0x0f, 0x75, 0x03, 0x0c, 0x71, 0x14, 0x8c, 0xec,
	0x4f, 0xc1, 0x62, 0xc4, 0xa1, 0x0e, 0xe3, 0x58, 0xcd, 0x5a, 0xb5, 0xce, 0x2f, 0xb6, 0x96, 0x1b,
	0x79, 0x17, 0x1b, 0x13, 0xad, 0xf6, 0x46, 0x9a, 0x38, 0x57, 0xbc, 0xee, 0x46, 0x7d, 0x4a, 0x6d,
	0x8d, 0xf4, 0x7d, 0x86, 0xfb, 0x11, 0x1b, 0xd5, 0x57, 0x07, 0x34, 0x98, 0x25, 0x83, 0x20, 0xca,
	0x78, 0xec, 0xdb, 0xa0, 0x22, 0x7c, 0xaf, 0x95, 0x84, 0x49, 0x7b, 0x6c, 0x92, 0x7f, 0x55, 0x63,
	0x8b, 0x4b, 0xda, 0x8d, 0x34, 0x71, 0x2e, 0x70, 0x53, 0xe2, 0xa0, 0x66, 0xa4, 0x88, 0x42, 0x49,
	0x58, 0xff, 0xb5, 0x0c, 0xce, 0x6c, 0x06, 0xc8, 0xef, 0xef, 0x52, 0xd2, 0x27, 0x9b, 0xc4, 0xc3,
	0x10, 0x7f, 0x32, 0xc0, 0x31, 0xb3, 0x6f, 0x80, 0x2a, 0xa1, 0xbd, 0x8e, 0xef, 0x89, 0xef, 0xac,
	0xb4, 0x2f, 0xa6, 0x89, 0xb3, 0xc6, 0x0d, 0x48, 0x54, 0xb3, 0xa0, 0xc1, 0xb0, 0x42, 0x68, 0x6f,
	0xdb, 0xb3, 0x5f, 0x07, 0x65, 0x97, 0x78, 0x58, 0xf8, 0xbe, 0xd0, 0x5e, 0x4b, 0x13, 0xe7, 0x3c,
	0xa7, 0xe1, 0x98, 0x46, 0x52, 0x00, 0xa1, 0xd0, 0xb4, 0xdf, 0x07, 0xc0, 0xe5, 0x3e, 0x62, 0xaf,
	0xd3, 0x1d, 0xd5, 0xe6, 0x84, 0x3b, 0x57, 0xd3, 0xc4, 0xb9, 0x2c, 0x78, 0x32, 0x89, 0xce, 0x66,
	0x12, 0xc1, 0x05, 0x05, 0xb7, 0x47, 0xf6, 0xb7, 0x16, 0x38, 0x41, 0xe5, 0xf7, 0x76, 0x5c, 0x44,
	0xa9, 0x8f, 0x69, 0xad, 0xbc, 0x3a, 0x77, 0x7e, 0xb1, 0xf5, 0x72, 0x31, 0xab, 0xc6, 0x20, 0x35,
	0xd4, 0xdf, 0x4d, 0xa9, 0xbb, 0x15, 0x32, 0x3a, 0x6a, 0xbf, 0x93, 0x26, 0xce, 0x36, 0xc5, 0x1e,
	0x72, 0xd9, 0x46, 0x7d, 0xbd, 0xbe, 0xca, 0x9d, 0x2c, 0x18, 0xd1, 0x3c, 0x9d, 0x2d, 0xff, 0xeb,
	0xef, 0x17, 0x2d, 0xb8, 0x44, 0x73, 0x76, 0x96, 0xbf, 0xb4, 0xc0, 0x29, 0x83, 0x69, 0xfb, 0x1a,
	0x98, 0x3b, 0xc4, 0x23, 0x91, 0xb0, 0x85, 0xf6, 0x85, 0x34, 0x71, 0xce, 0x71, 0xe3, 0x87, 0x58,
	0x0f, 0x4d, 0x1e, 0x83, 0x5c, 0xcd, 0xbe, 0x0e, 0x2a, 0x77, 0x51, 0x30, 0x18, 0x67, 0x2a, 0xbb,
	0x51, 0x02, 0xd4, 0x18, 0x8a, 0x28, 0x94, 0xca, 0x1b, 0xa5, 0xab, 0x56, 0xfd, 0x37, 0x0b, 0x9c,
	0x2a, 0x06, 0x8c, 0x17, 0x90, 0x07, 0x2a, 0x22, 0xf8, 0xaa, 0x74, 0x56, 0xf4, 0xd2, 0x51, 0xc7,
	0x85, 0xf2, 0xc4, 0x03, 0xa1, 0x64, 0x4e, 0x6f, 0xce, 0x03, 0x81, 0x3c, 0xc1, 0x6a, 0xf9, 0xa6,
	0x0c, 0x5e, 0x10, 0x7d, 0x61, 0xda, 0xcd, 0xf8, 0xc8, 0x2b, 0xe6, 0x7b, 0xc3, 0xb5, 0x2c, 0x89,
	0x6b, 0xf9, 0x6a, 0x31, 0x62, 0x33, 0xbd, 0xf9, 0x9f, 0xae, 0xa6, 0x7d, 0x08, 0x4e, 0xe0, 0xa1,
	0x1b, 0x0c, 0x3c, 0xdc, 0xc1, 0xc3, 0xc8, 0xa7, 0xd8, 0x13, 0x05, 0x7b, 0xac, 0xdd, 0x4e, 0x13,
	0xe7, 0x35, 0x11, 0xf2, 0xbc, 0x58, 0x0f, 0xfe, 0x4c, 0x39, 0x5c, 0x52, 0xb2, 0x2d, 0x29, 0x7a,
	0xea, 0xeb, 0xe0, 0x81, 0x05, 0x9e, 0x37, 0x65, 0x88, 0xd7, 0xc2, 0x01, 0xa8, 0x8a, 0xeb, 0x1a,
	0xd7, 0x2c, 0x91, 0xda, 0x47, 0x15, 0x43, 0x76, 0x9b, 0xa4, 0x96, 0xb9, 0x1a, 0xa6, 0x61, 0xa8,
	0xf8, 0x9f, 0x60, 0x3d, 0x7c, 0x5d, 0x01, 0x4b, 0x79, 0x37, 0x9f, 0xa6, 0xb1, 0xf1, 0x26, 0xa8,
	0xa2, 0x3e, 0x19, 0x84, 0x4c, 0xdc, 0xc0, 0xb9, 0x89, 0x2b, 0x12, 0xd5, 0x58, 0x34, 0x18, 0x2a,
	0x7d, 0xfb, 0x26, 0x98, 0xef, 0xa2, 0x00, 0x85, 0x2e, 0xae, 0x95, 0x05, 0x55, 0x2b, 0x4d, 0x9c,
	0x06, 0xa7, 0x52, 0xb0, 0xc6, 0xa5, 0xe3, 0x70, 0x4c, 0x61, 0xc7, 0x6a, 0x9c, 0x75, 0x3c, 0xc4,
	0x70, 0xad, 0xa2, 0xb6, 0x08, 0xb9, 0xc2, 0x34, 0xc6, 0x2b, 0x4c, 0x63, 0x6f, 0xbc, 0xc2, 0x14,
	0x46, 0x9d, 0xd0, 0x32, 0x67, 0xbf, 0x28, 0x52, 0xa3, 0xee, 0x3a, 0x62, 0xd8, 0xfe, 0xca, 0x02,
	0x67, 0x5d, 0x8a, 0x3d, 0x9f, 0xc9, 0xc2, 0x42, 0xcc, 0x27, 0xa1, 0xf4, 0xa0, 0xfa, 0x48, 0x0f,
	0x76, 0xd3, 0xc4, 0xb9, 0x29, 0x3c, 0x30, 0x32, 0xe8, 0xde, 0x3c, 0xea, 0x18, 0x3c, 0x2d, 0x8f,
	0x6c, 0x65, 0x27, 0x84, 0x93, 0xf9, 0x41, 0x3f, 0x7f, 0x64, 0x83, 0xbe, 0xfe, 0x73, 0x09, 0x80,
	0xc9, 0x5e, 0x66, 0x7f, 0x66, 0x15, 0x37, 0x39, 0x5e, 0x81, 0x17, 0x66, 0x6f, 0x72, 0x53, 0x3f,
	0x65, 0x27, 0x3d, 0xa2, 0xcd, 0x6e, 0x99, 0x6f, 0x20, 0x05, 0xee, 0xc7, 0xec, 0x5e, 0x1f, 0x4f,
	0x77, 0x2f, 0xc3, 0x7a, 0x7a, 0x2b, 0xf4, 0xe5, 0x62, 0x1b, 0x3f, 0x4e, 0x67, 0xfb, 0xbd, 0x04,
	0xc0, 0x84, 0xc9, 0x8e, 0x40, 0x55, 0x7c, 0xd4, 0xb8, 0x99, 0x9d, 0x9b, 0x6d, 0x55, 0x86, 0x32,
	0x96, 0x61, 0xcc, 0x4a, 0x52, 0x6a, 0x9b, 0x23, 0x98, 0x6f, 0x6a, 0x12, 0xe2, 0xed, 0x61, 0x10,
	0xfa, 0xac, 0xd8, 0x1e, 0x38, 0xa6, 0xb1, 0x14, 0x40, 0x28, 0x34, 0x97, 0xbf, 0xb0, 0xc0, 0xe2,
	0x94, 0x2f, 0x47, 0x39, 0x34, 0xac, 0xc7, 0x09, 0xed, 0xe7, 0x73, 0xa0, 0xbc, 0x89, 0xa8, 0x67,
	0xdf, 0x06, 0xc0, 0x45, 0xd4, 0x3b, 0x20, 0x81, 0x87, 0xa9, 0xf2, 0x6b, 0x52, 0x0d, 0x99, 0x44,
	0xaf, 0x06, 0x93, 0x08, 0x4e, 0x71, 0x71, 0x67, 0xbb, 0x14, 0x85, 0x5e, 0x71, 0xc2, 0x09, 0x50,
	0xef, 0x65, 0x05, 0x14, 0x4a, 0x65, 0xce, 0x12, 0xa0, 0x98, 0x5d, 0x16, 0xed, 0x75, 0x8a, 0x45,
	0x80, 0x1a, 0x4b, 0x11, 0x85, 0x52, 0xd9, 0x7e, 0x17, 0x2c, 0xe0, 0x61, 0xd4, 0xe9, 0x93, 0x90,
	0x1d, 0x88, 0xee, 0xba, 0xd0, 0xbe, 0x92, 0x26, 0x4e, 0x4b, 0xae, 0x0a, 0x4a, 0x60, 0x58, 0x12,
	0x74, 0x09, 0x3c, 0x86, 0x87, 0xd1, 0xdb, 0x1c, 0xb4, 0x77, 0x00, 0xff, 0xdd, 0x19, 0x61, 0x44,
	0x45, 0x83, 0x5d, 0x68, 0x5f, 0x4e, 0x13, 0xe7, 0xe2, 0x98, 0x93, 0xe3, 0x46, 0xca, 0x82, 0x00,
	0xce, 0xe3, 0x61, 0xf4, 0x01, 0x46, 0xb4, 0x7e, 0xbf, 0x0c, 0x4e, 0xf1, 0x49, 0x8e, 0x46, 0x7d,
	0x1c, 0xb2, 0xed, 0x70, 0x9f, 0xc8, 0x29, 0xfe, 0x1e, 0x28, 0xf3, 0xb8, 0xaa, 0x85, 0xf6, 0xb4,
	0xf6, 0x6a, 0x40, 0xd4, 0x9b, 0x9a, 0x5d, 0x88, 0x7a, 0xc6, 0x6c, 0xe5, 0x67, 0x17, 0xcf, 0xfd,
	0x3d, 0x70, 0x9c, 0xd0, 0x1e, 0x0a, 0xfd, 0x7b, 0xa2, 0x3b, 0x8a, 0x10, 0x2f, 0xb6, 0x6a, 0x63,
	0x7e, 0xfe, 0x70, 0xdd, 0x99, 0x92, 0xb7, 0xaf, 0xa5, 0x89, 0x73, 0x55, 0x8d, 0xd9, 0x0c, 0x35,
	0x0d, 0x5b, 0x93, 0x10, 0xe6, 0x6c, 0x3d, 0xb9, 0x7d, 0x81, 0x3f, 0xa0, 0x19, 0x1a, 0x76, 0x90,
	0xe7, 0x51, 0x1c, 0xc7, 0x22, 0xdb, 0x86, 0x0e, 0xb5, 0x87, 0x86, 0x6f, 0xc8, 0x13, 0x93, 0x36,
	0x3b, 0xa5, 0xa6, 0x59, 0x33, 0xcb, 0x20, 0x60, 0x19, 0x8f, 0xdd, 0x05, 0xf3, 0xfc, 0x94, 0xef,
	0xc5, 0xb5, 0x8a, 0x68, 0x50, 0x67, 0x0c, 0x46, 0xb7, 0xbd, 0xc9, 0x5c, 0x57, 0xa7, 0x8d, 0xb6,
	0xf2, 0x38, 0xac, 0x32, 0xae, 0x1a, 0xd7, 0x1f, 0x94, 0x41, 0xed, 0x56, 0xc4, 0x07, 0x5d, 0xee,
	0x96, 0xc8, 0xb7, 0xc1, 0x1d, 0x70, 0x3c, 0x66, 0xd4, 0x8f, 0x70, 0x87, 0x91, 0x43, 0x1c, 0xaa,
	0x6a, 0xbe, 0x91, 0x26, 0xce, 0x66, 0x61, 0x1f, 0x9f, 0x3e, 0xa6, 0x99, 0x9f, 0x21, 0x84, 0x8b,
	0x52, 0xb0, 0xc7, 0x71, 0xed, 0xee, 0x94, 0xfe, 0xc3, 0xbb, 0xf3, 0x9d, 0xe1, 0xe9, 0x32, 0x27,
	0x22, 0x7e, 0x4d, 0x1b, 0x09, 0x33, 0x62, 0xf5, 0xec, 0x51, 0x6d, 0x9e, 0x0b, 0x3f, 0x94, 0xc0,
	0x59, 0x43, 0xcc, 0x9e, 0x75, 0xa1, 0x7f, 0xfb, 0x6a, 0xf9, 0x69, 0x0e, 0x80, 0x49, 0x8f, 0x11,
	0x63, 0xcc, 0x0f, 0xf1, 0x25, 0x95, 0xe1, 0xc9, 0x18, 0xe3, 0xa0, 0x3e, 0xc6, 0x0a, 0x28, 0x94,
	0xca, 0x63, 0x96, 0x56, 0x31, 0xcf, 0x02, 0x34, 0xb2, 0xb4, 0x34, 0x96, 0x96, 0x78, 0xf4, 0xf8,
	0x6c, 0xa4, 0x26, 0xea, 0x24, 0x65, 0x3e, 0x33, 0x2c, 0xbd, 0x79, 0x10, 0x0a, 0x4d, 0xee, 0x47,
	0xcc, 0xf8, 0x56, 0x5f, 0xce, 0xfb, 0x21, 0x40, 0x43, 0x3f, 0x29, 0xec, 0xe5, 0x52, 0x99, 0x3f,
	0x78, 0x5c, 0xfe, 0xf2, 0xa1, 0x23, 0x35, 0x3e, 0xb3, 0xc6, 0xa8, 0x60, 0xc3, 0x13, 0xac, 0x88,
	0xc3, 0x31, 0x85, 0xfd, 0x11, 0x58, 0x8c, 0x48, 0xcc, 0x50, 0xd0, 0x11, 0x2f, 0xba, 0xaa, 0x60,
	0x9c, 0x6c, 0xd0, 0x13, 0x91, 0xbe, 0xff, 0x19, 0x65, 0x10, 0x48, 0x9c, 0xbf, 0x3a, 0xeb, 0xf7,
	0x4b, 0xa0, 0x22, 0x9a, 0x37, 0xdf, 0x24, 0xd8, 0x28, 0xc2, 0x1d, 0x1c, 0x0e, 0xfa, 0x2a, 0x99,
	0xd9, 0x26, 0x91, 0x09, 0xf4, 0x8e, 0x6e, 0x90, 0xc0, 0x63, 0x1c, 0xdd, 0x0a, 0x07, 0xe2, 0x3d,
	0x2b, 0x7b, 0xbe, 0x4a, 0x6c, 0xb6, 0xb1, 0x4a, 0x74, 0xc6, 0x80, 0xc8, 0x85, 0x54, 0xcc, 0x07,
	0x7b, 0x04, 0x4e, 0xaa, 0xee, 0x4d, 0xba, 0x77, 0xb0, 0xcb, 0x38, 0xa5, 0x4c, 0xf3, 0x4e, 0x9a,
	0x38, 0x6f, 0x99, 0xa7, 0x40, 0x76, 0x74, 0xd6, 0x24, 0x30, 0x1d, 0x80, 0x4b, 0x52, 0xb8, 0x23,
	0x64, 0xdb, 0x5e, 0x9b, 0xfd, 0xf8, 0x70, 0xc5, 0xfa, 0xe5, 0xe1, 0x8a, 0xf5, 0xc7, 0xc3, 0x15,
	0x0b, 0xac, 0xf9, 0xa4, 0xe1, 0x92, 0x70, 0x3f, 0x18, 0xe0, 0x90, 0x35, 0x64, 0x51, 0x65, 0x6f,
	0xbe, 0x43, 0xb4, 0x7f, 0x88, 0xb2, 0xc6, 0x71, 0xf7, 0xd2, 0xae, 0xf5, 0xe1, 0x95, 0x9e, 0xcf,
	0x0e, 0x06, 0xdd, 0x86, 0x4b, 0xfa, 0xcd, 0x4c, 0xcf, 0x0f, 0xdd, 0xa6, 0x2c, 0xc8, 0xf5, 0xd8,
	0x3b, 0x5c, 0xef, 0x91, 0xf5, 0xbb, 0x97, 0xd6, 0xa3, 0x41, 0x37, 0xf0, 0xdd, 0x57, 0x24, 0xde,
	0xad, 0x0a, 0xd2, 0x97, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x02, 0x64, 0x80, 0xbe, 0xda, 0x17,
	0x00, 0x00,
}

func (m *GetPriceTableReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetPriceTableReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.PriceTable != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.PriceTable.Size()))
		n1, err := m.PriceTable.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Error.Size()))
		n2, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ClaimPromoCodeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ClaimPromoCodeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OrgId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.OrgId))
	}
	if len(m.Code) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Code)))
		i += copy(dAtA[i:], m.Code)
	}
	if m.ClaimedBy != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.ClaimedBy))
	}
	if len(m.RequestCarrier) > 0 {
		for k, _ := range m.RequestCarrier {
			dAtA[i] = 0x22
			i++
			v := m.RequestCarrier[k]
			mapSize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			i = encodeVarintBilling(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ClaimPromoCodeReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ClaimPromoCodeReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Claim != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Claim.Size()))
		n3, err := m.Claim.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Error.Size()))
		n4, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetPromoCodeClaimsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetPromoCodeClaimsRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OrgId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.OrgId))
	}
	if len(m.RequestCarrier) > 0 {
		for k, _ := range m.RequestCarrier {
			dAtA[i] = 0x12
			i++
			v := m.RequestCarrier[k]
			mapSize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			i = encodeVarintBilling(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.ExcludeExpired {
		dAtA[i] = 0x18
		i++
		if m.ExcludeExpired {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetPromoCodeClaimsReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetPromoCodeClaimsReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Claims) > 0 {
		for _, msg := range m.Claims {
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Error.Size()))
		n5, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PromoCodeClaim) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PromoCodeClaim) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OrgId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.OrgId))
	}
	if len(m.Code) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Code)))
		i += copy(dAtA[i:], m.Code)
	}
	if m.Amount != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Amount))
	}
	if m.Balance != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Balance))
	}
	if m.ClaimDate != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.ClaimDate.Size()))
		n6, err := m.ClaimDate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.CreditExpirationDate != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.CreditExpirationDate.Size()))
		n7, err := m.CreditExpirationDate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.ClaimedBy != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.ClaimedBy))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PriceTable) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceTable) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PriceTable) > 0 {
		for k, _ := range m.PriceTable {
			dAtA[i] = 0xa
			i++
			v := m.PriceTable[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovBilling(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovBilling(uint64(len(k))) + msgSize
			i = encodeVarintBilling(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintBilling(dAtA, i, uint64(v.Size()))
				n8, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n8
			}
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UnitPrices) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnitPrices) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Prices) > 0 {
		for k, _ := range m.Prices {
			dAtA[i] = 0xa
			i++
			v := m.Prices[k]
			mapSize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + 8
			i = encodeVarintBilling(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x11
			i++
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i += 8
		}
	}
	if len(m.Unit) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Unit)))
		i += copy(dAtA[i:], m.Unit)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Card) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Card) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Cardholder) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Cardholder)))
		i += copy(dAtA[i:], m.Cardholder)
	}
	if len(m.Brand) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Brand)))
		i += copy(dAtA[i:], m.Brand)
	}
	if len(m.Last4) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Last4)))
		i += copy(dAtA[i:], m.Last4)
	}
	if len(m.ExpMonth) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.ExpMonth)))
		i += copy(dAtA[i:], m.ExpMonth)
	}
	if len(m.ExpYear) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.ExpYear)))
		i += copy(dAtA[i:], m.ExpYear)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetPaymentInfoReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetPaymentInfoReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Card != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Card.Size()))
		n9, err := m.Card.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Error.Size()))
		n10, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.Organization != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Organization.Size()))
		n11, err := m.Organization.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.TaxAddress != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.TaxAddress.Size()))
		n12, err := m.TaxAddress.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if len(m.TaxIds) > 0 {
		for _, msg := range m.TaxIds {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintBilling(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UpdatePaymentInfoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdatePaymentInfoRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.StripeToken) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.StripeToken)))
		i += copy(dAtA[i:], m.StripeToken)
	}
	if m.Organization != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Organization.Size()))
		n13, err := m.Organization.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if len(m.RequestCarrier) > 0 {
		for k, _ := range m.RequestCarrier {
			dAtA[i] = 0x1a
			i++
			v := m.RequestCarrier[k]
			mapSize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			i = encodeVarintBilling(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintBilling(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UpdatePaymentInfoReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdatePaymentInfoReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Card != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Card.Size()))
		n14, err := m.Card.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Error.Size()))
		n15, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.Organization != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(m.Organization.Size()))
		n16, err := m.Organization.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TaxAddress) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TaxAddress) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Line1) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Line1)))
		i += copy(dAtA[i:], m.Line1)
	}
	if len(m.Line2) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Line2)))
		i += copy(dAtA[i:], m.Line2)
	}
	if len(m.City) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.City)))
		i += copy(dAtA[i:], m.City)
	}
	if len(m.State) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.State)))
		i += copy(dAtA[i:], m.State)
	}
	if len(m.Country) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.Country)))
		i += copy(dAtA[i:], m.Country)
	}
	if len(m.PostalCode) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.PostalCode)))
		i += copy(dAtA[i:], m.PostalCode)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TaxId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TaxId) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TypeEnum) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.TypeEnum)))
		i += copy(dAtA[i:], m.TypeEnum)
	}
	if len(m.TaxId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.TaxId)))
		i += copy(dAtA[i:], m.TaxId)
	}
	if len(m.StripeObjectId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBilling(dAtA, i, uint64(len(m.StripeObjectId)))
		i += copy(dAtA[i:], m.StripeObjectId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintBilling(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *GetPriceTableReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PriceTable != nil {
		l = m.PriceTable.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClaimPromoCodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgId != 0 {
		n += 1 + sovBilling(uint64(m.OrgId))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.ClaimedBy != 0 {
		n += 1 + sovBilling(uint64(m.ClaimedBy))
	}
	if len(m.RequestCarrier) > 0 {
		for k, v := range m.RequestCarrier {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			n += mapEntrySize + 1 + sovBilling(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClaimPromoCodeReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Claim != nil {
		l = m.Claim.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetPromoCodeClaimsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgId != 0 {
		n += 1 + sovBilling(uint64(m.OrgId))
	}
	if len(m.RequestCarrier) > 0 {
		for k, v := range m.RequestCarrier {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			n += mapEntrySize + 1 + sovBilling(uint64(mapEntrySize))
		}
	}
	if m.ExcludeExpired {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetPromoCodeClaimsReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Claims) > 0 {
		for _, e := range m.Claims {
			l = e.Size()
			n += 1 + l + sovBilling(uint64(l))
		}
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PromoCodeClaim) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgId != 0 {
		n += 1 + sovBilling(uint64(m.OrgId))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovBilling(uint64(m.Amount))
	}
	if m.Balance != 0 {
		n += 1 + sovBilling(uint64(m.Balance))
	}
	if m.ClaimDate != nil {
		l = m.ClaimDate.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.CreditExpirationDate != nil {
		l = m.CreditExpirationDate.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.ClaimedBy != 0 {
		n += 1 + sovBilling(uint64(m.ClaimedBy))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PriceTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PriceTable) > 0 {
		for k, v := range m.PriceTable {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovBilling(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovBilling(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovBilling(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnitPrices) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Prices) > 0 {
		for k, v := range m.Prices {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 1 + sovBilling(uint64(mapEntrySize))
		}
	}
	l = len(m.Unit)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Card) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Cardholder)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.Brand)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.Last4)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.ExpMonth)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.ExpYear)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetPaymentInfoReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Card != nil {
		l = m.Card.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Organization != nil {
		l = m.Organization.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.TaxAddress != nil {
		l = m.TaxAddress.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if len(m.TaxIds) > 0 {
		for _, e := range m.TaxIds {
			l = e.Size()
			n += 1 + l + sovBilling(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdatePaymentInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StripeToken)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Organization != nil {
		l = m.Organization.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if len(m.RequestCarrier) > 0 {
		for k, v := range m.RequestCarrier {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovBilling(uint64(len(k))) + 1 + len(v) + sovBilling(uint64(len(v)))
			n += mapEntrySize + 1 + sovBilling(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdatePaymentInfoReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Card != nil {
		l = m.Card.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.Organization != nil {
		l = m.Organization.Size()
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TaxAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Line1)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.Line2)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.City)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.Country)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.PostalCode)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TaxId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TypeEnum)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.TaxId)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	l = len(m.StripeObjectId)
	if l > 0 {
		n += 1 + l + sovBilling(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovBilling(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozBilling(x uint64) (n int) {
	return sovBilling(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GetPriceTableReply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPriceTableReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPriceTableReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceTable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PriceTable == nil {
				m.PriceTable = &PriceTable{}
			}
			if err := m.PriceTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClaimPromoCodeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ClaimPromoCodeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClaimPromoCodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgId", wireType)
			}
			m.OrgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrgId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimedBy", wireType)
			}
			m.ClaimedBy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClaimedBy |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestCarrier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestCarrier == nil {
				m.RequestCarrier = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBilling(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBilling
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequestCarrier[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClaimPromoCodeReply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ClaimPromoCodeReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClaimPromoCodeReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Claim", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Claim == nil {
				m.Claim = &PromoCodeClaim{}
			}
			if err := m.Claim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetPromoCodeClaimsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPromoCodeClaimsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPromoCodeClaimsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgId", wireType)
			}
			m.OrgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrgId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestCarrier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestCarrier == nil {
				m.RequestCarrier = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBilling(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBilling
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequestCarrier[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExcludeExpired", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExcludeExpired = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetPromoCodeClaimsReply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPromoCodeClaimsReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPromoCodeClaimsReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Claims", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Claims = append(m.Claims, &PromoCodeClaim{})
			if err := m.Claims[len(m.Claims)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PromoCodeClaim) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PromoCodeClaim: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PromoCodeClaim: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgId", wireType)
			}
			m.OrgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrgId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
			}
			m.Balance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimDate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClaimDate == nil {
				m.ClaimDate = &types.Timestamp{}
			}
			if err := m.ClaimDate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditExpirationDate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreditExpirationDate == nil {
				m.CreditExpirationDate = &types.Timestamp{}
			}
			if err := m.CreditExpirationDate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimedBy", wireType)
			}
			m.ClaimedBy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClaimedBy |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceTable) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceTable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceTable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceTable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PriceTable == nil {
				m.PriceTable = make(map[string]*UnitPrices)
			}
			var mapkey string
			var mapvalue *UnitPrices
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthBilling
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthBilling
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &UnitPrices{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBilling(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBilling
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.PriceTable[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnitPrices) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnitPrices: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnitPrices: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prices == nil {
				m.Prices = make(map[string]float64)
			}
			var mapkey string
			var mapvalue float64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					mapvalue = math.Float64frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBilling(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBilling
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Prices[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Card) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Card: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Card: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cardholder", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cardholder = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Brand", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Brand = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Last4", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Last4 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpMonth", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpMonth = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpYear", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpYear = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetPaymentInfoReply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPaymentInfoReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPaymentInfoReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Card", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Card == nil {
				m.Card = &Card{}
			}
			if err := m.Card.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Organization == nil {
				m.Organization = &Organization{}
			}
			if err := m.Organization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TaxAddress == nil {
				m.TaxAddress = &TaxAddress{}
			}
			if err := m.TaxAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaxIds = append(m.TaxIds, &TaxId{})
			if err := m.TaxIds[len(m.TaxIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdatePaymentInfoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdatePaymentInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdatePaymentInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StripeToken", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StripeToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Organization == nil {
				m.Organization = &Organization{}
			}
			if err := m.Organization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestCarrier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestCarrier == nil {
				m.RequestCarrier = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBilling
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthBilling
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBilling(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBilling
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequestCarrier[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdatePaymentInfoReply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdatePaymentInfoReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdatePaymentInfoReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Card", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Card == nil {
				m.Card = &Card{}
			}
			if err := m.Card.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Organization == nil {
				m.Organization = &Organization{}
			}
			if err := m.Organization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaxAddress) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TaxAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaxAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Line1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Line1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Line2", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Line2 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field City", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.City = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Country", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Country = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostalCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PostalCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaxId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TaxId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaxId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TypeEnum", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TypeEnum = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaxId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StripeObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBilling
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBilling
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StripeObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBilling(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBilling
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBilling(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowBilling
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBilling
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthBilling
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthBilling
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowBilling
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipBilling(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthBilling
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthBilling = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBilling   = fmt.Errorf("proto: integer overflow")
)