credits.pb.go

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

package v1

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	v1 "github.com/arangodb-managed/apis/common/v1"
	types "github.com/gogo/protobuf/types"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

// CreditBundleUsageProjection contains a series of monthly credit usage projections.
type CreditBundleUsageProjection struct {
	// List of credit usage projections.
	Projections          []*CreditBundleUsageProjection_Projection `protobuf:"bytes,1,rep,name=projections,proto3" json:"projections,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
	XXX_unrecognized     []byte                                    `json:"-"`
	XXX_sizecache        int32                                     `json:"-"`
}

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

var xxx_messageInfo_CreditBundleUsageProjection proto.InternalMessageInfo

func (m *CreditBundleUsageProjection) GetProjections() []*CreditBundleUsageProjection_Projection {
	if m != nil {
		return m.Projections
	}
	return nil
}

type CreditBundleUsageProjection_Projection struct {
	// Usage value projected for the month in the provided timestamp.
	Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
	// Timestamp (month) for which the given usage value is projected.
	Timestamp            *types.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_CreditBundleUsageProjection_Projection proto.InternalMessageInfo

func (m *CreditBundleUsageProjection_Projection) GetValue() float32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *CreditBundleUsageProjection_Projection) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// Request for GetCreditBundleUsageProjection rpc.
type GetCreditBundleUsageProjectionRequest struct {
	// Identifier of the organization for which a credit usage projection is requested.
	OrganizationId string `protobuf:"bytes,1,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// Maximum number of projections to return.
	// This is an optional field.
	// If unspecified, defaults to 3.
	ProjectionsLimit     int32    `protobuf:"varint,2,opt,name=projections_limit,json=projectionsLimit,proto3" json:"projections_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetCreditBundleUsageProjectionRequest proto.InternalMessageInfo

func (m *GetCreditBundleUsageProjectionRequest) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

func (m *GetCreditBundleUsageProjectionRequest) GetProjectionsLimit() int32 {
	if m != nil {
		return m.ProjectionsLimit
	}
	return 0
}

type CreditUsageReportList struct {
	// List of credit usage reports.
	Items                []*CreditUsageReport `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_CreditUsageReportList proto.InternalMessageInfo

func (m *CreditUsageReportList) GetItems() []*CreditUsageReport {
	if m != nil {
		return m.Items
	}
	return nil
}

// Request for ListCreditUsageReports rpc.
type ListCreditUsageReportsRequest struct {
	// Identifier of the organization for which credit reports are listed.
	OrganizationId string `protobuf:"bytes,1,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// Request reports that are created at or after this timestamp.
	// This is an optional field.
	From *types.Timestamp `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	// Request reports that are created before this timestamp.
	// This is an optional field.
	To *types.Timestamp `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	// Common list options
	// context_id is ignored.
	Options              *v1.ListOptions `protobuf:"bytes,20,opt,name=options,proto3" json:"options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_ListCreditUsageReportsRequest proto.InternalMessageInfo

func (m *ListCreditUsageReportsRequest) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

func (m *ListCreditUsageReportsRequest) GetFrom() *types.Timestamp {
	if m != nil {
		return m.From
	}
	return nil
}

func (m *ListCreditUsageReportsRequest) GetTo() *types.Timestamp {
	if m != nil {
		return m.To
	}
	return nil
}

func (m *ListCreditUsageReportsRequest) GetOptions() *v1.ListOptions {
	if m != nil {
		return m.Options
	}
	return nil
}

// CreditUsageReport describes the monthly credit usage for a given organization.
type CreditUsageReport struct {
	// System identifier of the report.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// URL of this resource
	Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// ID of the organization to which this report belongs.
	OrganizationId string `protobuf:"bytes,3,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// Amount of credits consumed between the interval in this report (between starts_at and ends_at).
	Amount float32 `protobuf:"fixed32,4,opt,name=amount,proto3" json:"amount,omitempty"`
	// Credit balance at the start of the month.
	OpeningBalance float32 `protobuf:"fixed32,5,opt,name=opening_balance,json=openingBalance,proto3" json:"opening_balance,omitempty"`
	// Credit balance at the end of the month.
	ClosingBalance float32 `protobuf:"fixed32,6,opt,name=closing_balance,json=closingBalance,proto3" json:"closing_balance,omitempty"`
	// Date at which this report was created.
	// This report will contain the monthly usage of the month specified in this timestamp.
	CreatedAt *types.Timestamp `protobuf:"bytes,7,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// List of items in this credit usage report.
	Items []*CreditUsageReport_Item `protobuf:"bytes,100,rep,name=items,proto3" json:"items,omitempty"`
	// Status of the report.
	Status               *CreditUsageReport_Status `protobuf:"bytes,200,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_CreditUsageReport proto.InternalMessageInfo

func (m *CreditUsageReport) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *CreditUsageReport) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *CreditUsageReport) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

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

func (m *CreditUsageReport) GetOpeningBalance() float32 {
	if m != nil {
		return m.OpeningBalance
	}
	return 0
}

func (m *CreditUsageReport) GetClosingBalance() float32 {
	if m != nil {
		return m.ClosingBalance
	}
	return 0
}

func (m *CreditUsageReport) GetCreatedAt() *types.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *CreditUsageReport) GetItems() []*CreditUsageReport_Item {
	if m != nil {
		return m.Items
	}
	return nil
}

func (m *CreditUsageReport) GetStatus() *CreditUsageReport_Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type CreditUsageReport_Item struct {
	// Identifiers of the Credit usages that this item covers.
	CreditusageIds []string `protobuf:"bytes,1,rep,name=creditusage_ids,json=creditusageIds,proto3" json:"creditusage_ids,omitempty"`
	// Amount of credits for this item.
	Amount float32 `protobuf:"fixed32,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// Human readable description of this item
	Description          string   `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreditUsageReport_Item proto.InternalMessageInfo

func (m *CreditUsageReport_Item) GetCreditusageIds() []string {
	if m != nil {
		return m.CreditusageIds
	}
	return nil
}

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

func (m *CreditUsageReport_Item) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// Status of the report.
type CreditUsageReport_Status struct {
	// If set, the items in this report are complete for the month specified in `created_at`.
	// No more items will be added to this report once this field is set.
	IsComplete           bool     `protobuf:"varint,1,opt,name=is_complete,json=isComplete,proto3" json:"is_complete,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreditUsageReport_Status proto.InternalMessageInfo

func (m *CreditUsageReport_Status) GetIsComplete() bool {
	if m != nil {
		return m.IsComplete
	}
	return false
}

// PDFDocument contains the PDF representation of a CreditUsageReport.
type PDFDocument struct {
	// The contents of the PDF.
	// This is a read-only field.
	Contents []byte `protobuf:"bytes,1,opt,name=contents,proto3" json:"contents,omitempty"`
	// Name of the PDF file.
	// This is a ready-only field.
	Filename             string   `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PDFDocument proto.InternalMessageInfo

func (m *PDFDocument) GetContents() []byte {
	if m != nil {
		return m.Contents
	}
	return nil
}

func (m *PDFDocument) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

// Request for listing credit bundle usages.
type ListCreditBundleUsageRequest struct {
	// The organization this credit bundle belongs to.
	// This is a required field.
	OrganizationId string `protobuf:"bytes,1,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// If set, list the usage for the specified credit bundle only.
	// By default, returns the usage for all credit bundles in this organization.
	// This is an optional field.
	CreditBundleId string `protobuf:"bytes,2,opt,name=credit_bundle_id,json=creditBundleId,proto3" json:"credit_bundle_id,omitempty"`
	// The date from which credit usage should be listed.
	// If unspecified, defaults to the date 7 days before `ends_at`.
	// This is an optional field.
	StartsAt *types.Timestamp `protobuf:"bytes,3,opt,name=starts_at,json=startsAt,proto3" json:"starts_at,omitempty"`
	// The date until which credit usage should be listed.
	// If unspecified, defaults to the current date (at the time of calling the API).
	// This is an optional field.
	EndsAt *types.Timestamp `protobuf:"bytes,4,opt,name=ends_at,json=endsAt,proto3" json:"ends_at,omitempty"`
	// If set, list the usage for the specified usage item only.
	// This is an optional field.
	UsageItemId string `protobuf:"bytes,5,opt,name=usage_item_id,json=usageItemId,proto3" json:"usage_item_id,omitempty"`
	// Common list options
	// context_id is ignored.
	Options              *v1.ListOptions `protobuf:"bytes,20,opt,name=options,proto3" json:"options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_ListCreditBundleUsageRequest proto.InternalMessageInfo

func (m *ListCreditBundleUsageRequest) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

func (m *ListCreditBundleUsageRequest) GetCreditBundleId() string {
	if m != nil {
		return m.CreditBundleId
	}
	return ""
}

func (m *ListCreditBundleUsageRequest) GetStartsAt() *types.Timestamp {
	if m != nil {
		return m.StartsAt
	}
	return nil
}

func (m *ListCreditBundleUsageRequest) GetEndsAt() *types.Timestamp {
	if m != nil {
		return m.EndsAt
	}
	return nil
}

func (m *ListCreditBundleUsageRequest) GetUsageItemId() string {
	if m != nil {
		return m.UsageItemId
	}
	return ""
}

func (m *ListCreditBundleUsageRequest) GetOptions() *v1.ListOptions {
	if m != nil {
		return m.Options
	}
	return nil
}

// Request for listing credit bundles
type ListCreditBundlesRequest struct {
	// ID of the organization for which credit bundles are listed.
	// This is a required field.
	OrganizationId string `protobuf:"bytes,1,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// If set, exclude expired bundles.
	ExcludeExpired       bool     `protobuf:"varint,2,opt,name=exclude_expired,json=excludeExpired,proto3" json:"exclude_expired,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListCreditBundlesRequest proto.InternalMessageInfo

func (m *ListCreditBundlesRequest) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

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

// List of credit bundles
type CreditBundlesList struct {
	Items                []*CreditBundle `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_CreditBundlesList proto.InternalMessageInfo

func (m *CreditBundlesList) GetItems() []*CreditBundle {
	if m != nil {
		return m.Items
	}
	return nil
}

type CreditBundle struct {
	// ID of the credit bundle.
	// This is a read-only value.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// URL of this credit bundle.
	// This is a read-only value.
	Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// The organization this credit bundle belongs to.
	// This is a read-only value.
	OrganizationId string `protobuf:"bytes,4,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// The number of credits purchased in this bundle.
	// This is a read-only value.
	CreditsPurchased float32 `protobuf:"fixed32,5,opt,name=credits_purchased,json=creditsPurchased,proto3" json:"credits_purchased,omitempty"`
	// The total price of these credits.
	// This is a read-only value.
	TotalPrice float32 `protobuf:"fixed32,6,opt,name=total_price,json=totalPrice,proto3" json:"total_price,omitempty"`
	// Currency used for total_price.
	// This is a read-only value.
	Currency string `protobuf:"bytes,7,opt,name=currency,proto3" json:"currency,omitempty"`
	// The number of credits remaining in this bundle.
	// This is a read-only value.
	CreditsRemaining float32 `protobuf:"fixed32,8,opt,name=credits_remaining,json=creditsRemaining,proto3" json:"credits_remaining,omitempty"`
	// The date at which this bundle was purchased.
	// This is a read-only value.
	PurchasedAt *types.Timestamp `protobuf:"bytes,9,opt,name=purchased_at,json=purchasedAt,proto3" json:"purchased_at,omitempty"`
	// The date from which this bundle is valid.
	// This is a read-only value.
	ValidFrom *types.Timestamp `protobuf:"bytes,10,opt,name=valid_from,json=validFrom,proto3" json:"valid_from,omitempty"`
	// The date until which this bundle is valid.
	// This is a read-only value.
	ValidUntil *types.Timestamp `protobuf:"bytes,11,opt,name=valid_until,json=validUntil,proto3" json:"valid_until,omitempty"`
	// Timestamp of when this credit bundle was last used.
	LastUsedAt           *types.Timestamp `protobuf:"bytes,12,opt,name=last_used_at,json=lastUsedAt,proto3" json:"last_used_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_CreditBundle proto.InternalMessageInfo

func (m *CreditBundle) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *CreditBundle) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *CreditBundle) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

func (m *CreditBundle) GetCreditsPurchased() float32 {
	if m != nil {
		return m.CreditsPurchased
	}
	return 0
}

func (m *CreditBundle) GetTotalPrice() float32 {
	if m != nil {
		return m.TotalPrice
	}
	return 0
}

func (m *CreditBundle) GetCurrency() string {
	if m != nil {
		return m.Currency
	}
	return ""
}

func (m *CreditBundle) GetCreditsRemaining() float32 {
	if m != nil {
		return m.CreditsRemaining
	}
	return 0
}

func (m *CreditBundle) GetPurchasedAt() *types.Timestamp {
	if m != nil {
		return m.PurchasedAt
	}
	return nil
}

func (m *CreditBundle) GetValidFrom() *types.Timestamp {
	if m != nil {
		return m.ValidFrom
	}
	return nil
}

func (m *CreditBundle) GetValidUntil() *types.Timestamp {
	if m != nil {
		return m.ValidUntil
	}
	return nil
}

func (m *CreditBundle) GetLastUsedAt() *types.Timestamp {
	if m != nil {
		return m.LastUsedAt
	}
	return nil
}

// Usage of credit bundle.
// All fields are read-only.
type CreditBundleUsage struct {
	// Unique identifier of this credit bundle usage.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// ID of the usage item this credit bundle usage corresponds to.
	UsageItemId string `protobuf:"bytes,2,opt,name=usage_item_id,json=usageItemId,proto3" json:"usage_item_id,omitempty"`
	// ID of the credit bundle from which credit was used.
	CreditBundleId string `protobuf:"bytes,3,opt,name=credit_bundle_id,json=creditBundleId,proto3" json:"credit_bundle_id,omitempty"`
	// ID of the organization this credit bundle (and usage) belongs to.
	OrganizationId string `protobuf:"bytes,4,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	// Amount of credits used from the specified credit_bundle_id.
	Usage float32 `protobuf:"fixed32,5,opt,name=usage,proto3" json:"usage,omitempty"`
	// Amount of credits remaining after this usage.
	Remaining float32 `protobuf:"fixed32,6,opt,name=remaining,proto3" json:"remaining,omitempty"`
	// Timestamp at which this credit usage was created.
	CreatedAt            *types.Timestamp `protobuf:"bytes,7,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_CreditBundleUsage proto.InternalMessageInfo

func (m *CreditBundleUsage) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *CreditBundleUsage) GetUsageItemId() string {
	if m != nil {
		return m.UsageItemId
	}
	return ""
}

func (m *CreditBundleUsage) GetCreditBundleId() string {
	if m != nil {
		return m.CreditBundleId
	}
	return ""
}

func (m *CreditBundleUsage) GetOrganizationId() string {
	if m != nil {
		return m.OrganizationId
	}
	return ""
}

func (m *CreditBundleUsage) GetUsage() float32 {
	if m != nil {
		return m.Usage
	}
	return 0
}

func (m *CreditBundleUsage) GetRemaining() float32 {
	if m != nil {
		return m.Remaining
	}
	return 0
}

func (m *CreditBundleUsage) GetCreatedAt() *types.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

// List of CreditBundleUsages.
type CreditBundleUsageList struct {
	Items                []*CreditBundleUsage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_CreditBundleUsageList proto.InternalMessageInfo

func (m *CreditBundleUsageList) GetItems() []*CreditBundleUsage {
	if m != nil {
		return m.Items
	}
	return nil
}

func init() {
	proto.RegisterType((*CreditBundleUsageProjection)(nil), "arangodb.cloud.credits.v1.CreditBundleUsageProjection")
	proto.RegisterType((*CreditBundleUsageProjection_Projection)(nil), "arangodb.cloud.credits.v1.CreditBundleUsageProjection.Projection")
	proto.RegisterType((*GetCreditBundleUsageProjectionRequest)(nil), "arangodb.cloud.credits.v1.GetCreditBundleUsageProjectionRequest")
	proto.RegisterType((*CreditUsageReportList)(nil), "arangodb.cloud.credits.v1.CreditUsageReportList")
	proto.RegisterType((*ListCreditUsageReportsRequest)(nil), "arangodb.cloud.credits.v1.ListCreditUsageReportsRequest")
	proto.RegisterType((*CreditUsageReport)(nil), "arangodb.cloud.credits.v1.CreditUsageReport")
	proto.RegisterType((*CreditUsageReport_Item)(nil), "arangodb.cloud.credits.v1.CreditUsageReport.Item")
	proto.RegisterType((*CreditUsageReport_Status)(nil), "arangodb.cloud.credits.v1.CreditUsageReport.Status")
	proto.RegisterType((*PDFDocument)(nil), "arangodb.cloud.credits.v1.PDFDocument")
	proto.RegisterType((*ListCreditBundleUsageRequest)(nil), "arangodb.cloud.credits.v1.ListCreditBundleUsageRequest")
	proto.RegisterType((*ListCreditBundlesRequest)(nil), "arangodb.cloud.credits.v1.ListCreditBundlesRequest")
	proto.RegisterType((*CreditBundlesList)(nil), "arangodb.cloud.credits.v1.CreditBundlesList")
	proto.RegisterType((*CreditBundle)(nil), "arangodb.cloud.credits.v1.CreditBundle")
	proto.RegisterType((*CreditBundleUsage)(nil), "arangodb.cloud.credits.v1.CreditBundleUsage")
	proto.RegisterType((*CreditBundleUsageList)(nil), "arangodb.cloud.credits.v1.CreditBundleUsageList")
}

func init() { proto.RegisterFile("credits.proto", fileDescriptor_a0331d70383bb145) }

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

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

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

// CreditsServiceClient is the client API for CreditsService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CreditsServiceClient interface {
	// Get the current API version of this service.
	// Required permissions:
	// - None (authenticated only)
	GetAPIVersion(ctx context.Context, in *v1.Empty, opts ...grpc.CallOption) (*v1.Version, error)
	// List credit bundles for an organization based on the provided request.
	// Required permissions:
	// - credit.creditbundle.list on the organization identified by the given organization ID
	ListCreditBundles(ctx context.Context, in *ListCreditBundlesRequest, opts ...grpc.CallOption) (*CreditBundlesList, error)
	// List credit bundle usages for an organization based on the provided request.
	// Required permissions:
	// - credit.creditbundleusage.list on the organization identified by the given organization ID.
	ListCreditBundlesUsage(ctx context.Context, in *ListCreditBundleUsageRequest, opts ...grpc.CallOption) (*CreditBundleUsageList, error)
	// List the credit reports for the organization identified by the given
	// organization ID that match the given criteria.
	// Required permissions:
	// - credit.creditusagereport.list on the organization identified by the given organization ID
	ListCreditUsageReports(ctx context.Context, in *ListCreditUsageReportsRequest, opts ...grpc.CallOption) (*CreditUsageReportList, error)
	// Get a credit usage report identified by the given ID.
	// Required permissions:
	// - credit.creditusagereport.get on the organization that owns the report.
	GetCreditUsageReport(ctx context.Context, in *v1.IDOptions, opts ...grpc.CallOption) (*CreditUsageReport, error)
	// Get a credit usage report identified by the given ID, as a PDF document.
	// The server sends the PDF over a stream once rendered.
	// The stream is closed after the PDF is sent.
	// Required permissions:
	// - credit.creditusagereport.get on the organization that owns the report.
	GetCreditUsageReportPDF(ctx context.Context, in *v1.IDOptions, opts ...grpc.CallOption) (CreditsService_GetCreditUsageReportPDFClient, error)
	// Get credit usage projection for an organization identified by the given organization ID.
	// This will return a projected credit usage for each month in the future, until the credits run out.
	// Required permissions:
	// - credit.creditbundleusageprojection.get on the organization identified by the given organization ID.
	GetCreditBundleUsageProjection(ctx context.Context, in *GetCreditBundleUsageProjectionRequest, opts ...grpc.CallOption) (*CreditBundleUsageProjection, error)
}

type creditsServiceClient struct {
	cc *grpc.ClientConn
}

func NewCreditsServiceClient(cc *grpc.ClientConn) CreditsServiceClient {
	return &creditsServiceClient{cc}
}

func (c *creditsServiceClient) GetAPIVersion(ctx context.Context, in *v1.Empty, opts ...grpc.CallOption) (*v1.Version, error) {
	out := new(v1.Version)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/GetAPIVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *creditsServiceClient) ListCreditBundles(ctx context.Context, in *ListCreditBundlesRequest, opts ...grpc.CallOption) (*CreditBundlesList, error) {
	out := new(CreditBundlesList)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/ListCreditBundles", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *creditsServiceClient) ListCreditBundlesUsage(ctx context.Context, in *ListCreditBundleUsageRequest, opts ...grpc.CallOption) (*CreditBundleUsageList, error) {
	out := new(CreditBundleUsageList)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/ListCreditBundlesUsage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *creditsServiceClient) ListCreditUsageReports(ctx context.Context, in *ListCreditUsageReportsRequest, opts ...grpc.CallOption) (*CreditUsageReportList, error) {
	out := new(CreditUsageReportList)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/ListCreditUsageReports", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *creditsServiceClient) GetCreditUsageReport(ctx context.Context, in *v1.IDOptions, opts ...grpc.CallOption) (*CreditUsageReport, error) {
	out := new(CreditUsageReport)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/GetCreditUsageReport", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *creditsServiceClient) GetCreditUsageReportPDF(ctx context.Context, in *v1.IDOptions, opts ...grpc.CallOption) (CreditsService_GetCreditUsageReportPDFClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CreditsService_serviceDesc.Streams[0], "/arangodb.cloud.credits.v1.CreditsService/GetCreditUsageReportPDF", opts...)
	if err != nil {
		return nil, err
	}
	x := &creditsServiceGetCreditUsageReportPDFClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CreditsService_GetCreditUsageReportPDFClient interface {
	Recv() (*PDFDocument, error)
	grpc.ClientStream
}

type creditsServiceGetCreditUsageReportPDFClient struct {
	grpc.ClientStream
}

func (x *creditsServiceGetCreditUsageReportPDFClient) Recv() (*PDFDocument, error) {
	m := new(PDFDocument)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *creditsServiceClient) GetCreditBundleUsageProjection(ctx context.Context, in *GetCreditBundleUsageProjectionRequest, opts ...grpc.CallOption) (*CreditBundleUsageProjection, error) {
	out := new(CreditBundleUsageProjection)
	err := c.cc.Invoke(ctx, "/arangodb.cloud.credits.v1.CreditsService/GetCreditBundleUsageProjection", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CreditsServiceServer is the server API for CreditsService service.
type CreditsServiceServer interface {
	// Get the current API version of this service.
	// Required permissions:
	// - None (authenticated only)
	GetAPIVersion(context.Context, *v1.Empty) (*v1.Version, error)
	// List credit bundles for an organization based on the provided request.
	// Required permissions:
	// - credit.creditbundle.list on the organization identified by the given organization ID
	ListCreditBundles(context.Context, *ListCreditBundlesRequest) (*CreditBundlesList, error)
	// List credit bundle usages for an organization based on the provided request.
	// Required permissions:
	// - credit.creditbundleusage.list on the organization identified by the given organization ID.
	ListCreditBundlesUsage(context.Context, *ListCreditBundleUsageRequest) (*CreditBundleUsageList, error)
	// List the credit reports for the organization identified by the given
	// organization ID that match the given criteria.
	// Required permissions:
	// - credit.creditusagereport.list on the organization identified by the given organization ID
	ListCreditUsageReports(context.Context, *ListCreditUsageReportsRequest) (*CreditUsageReportList, error)
	// Get a credit usage report identified by the given ID.
	// Required permissions:
	// - credit.creditusagereport.get on the organization that owns the report.
	GetCreditUsageReport(context.Context, *v1.IDOptions) (*CreditUsageReport, error)
	// Get a credit usage report identified by the given ID, as a PDF document.
	// The server sends the PDF over a stream once rendered.
	// The stream is closed after the PDF is sent.
	// Required permissions:
	// - credit.creditusagereport.get on the organization that owns the report.
	GetCreditUsageReportPDF(*v1.IDOptions, CreditsService_GetCreditUsageReportPDFServer) error
	// Get credit usage projection for an organization identified by the given organization ID.
	// This will return a projected credit usage for each month in the future, until the credits run out.
	// Required permissions:
	// - credit.creditbundleusageprojection.get on the organization identified by the given organization ID.
	GetCreditBundleUsageProjection(context.Context, *GetCreditBundleUsageProjectionRequest) (*CreditBundleUsageProjection, error)
}

// UnimplementedCreditsServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCreditsServiceServer struct {
}

func (*UnimplementedCreditsServiceServer) GetAPIVersion(ctx context.Context, req *v1.Empty) (*v1.Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAPIVersion not implemented")
}
func (*UnimplementedCreditsServiceServer) ListCreditBundles(ctx context.Context, req *ListCreditBundlesRequest) (*CreditBundlesList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCreditBundles not implemented")
}
func (*UnimplementedCreditsServiceServer) ListCreditBundlesUsage(ctx context.Context, req *ListCreditBundleUsageRequest) (*CreditBundleUsageList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCreditBundlesUsage not implemented")
}
func (*UnimplementedCreditsServiceServer) ListCreditUsageReports(ctx context.Context, req *ListCreditUsageReportsRequest) (*CreditUsageReportList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCreditUsageReports not implemented")
}
func (*UnimplementedCreditsServiceServer) GetCreditUsageReport(ctx context.Context, req *v1.IDOptions) (*CreditUsageReport, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCreditUsageReport not implemented")
}
func (*UnimplementedCreditsServiceServer) GetCreditUsageReportPDF(req *v1.IDOptions, srv CreditsService_GetCreditUsageReportPDFServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCreditUsageReportPDF not implemented")
}
func (*UnimplementedCreditsServiceServer) GetCreditBundleUsageProjection(ctx context.Context, req *GetCreditBundleUsageProjectionRequest) (*CreditBundleUsageProjection, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCreditBundleUsageProjection not implemented")
}

func RegisterCreditsServiceServer(s *grpc.Server, srv CreditsServiceServer) {
	s.RegisterService(&_CreditsService_serviceDesc, srv)
}

func _CreditsService_GetAPIVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).GetAPIVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/GetAPIVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).GetAPIVersion(ctx, req.(*v1.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreditsService_ListCreditBundles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCreditBundlesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).ListCreditBundles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/ListCreditBundles",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).ListCreditBundles(ctx, req.(*ListCreditBundlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreditsService_ListCreditBundlesUsage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCreditBundleUsageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).ListCreditBundlesUsage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/ListCreditBundlesUsage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).ListCreditBundlesUsage(ctx, req.(*ListCreditBundleUsageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreditsService_ListCreditUsageReports_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCreditUsageReportsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).ListCreditUsageReports(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/ListCreditUsageReports",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).ListCreditUsageReports(ctx, req.(*ListCreditUsageReportsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreditsService_GetCreditUsageReport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.IDOptions)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).GetCreditUsageReport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/GetCreditUsageReport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).GetCreditUsageReport(ctx, req.(*v1.IDOptions))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreditsService_GetCreditUsageReportPDF_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(v1.IDOptions)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CreditsServiceServer).GetCreditUsageReportPDF(m, &creditsServiceGetCreditUsageReportPDFServer{stream})
}

type CreditsService_GetCreditUsageReportPDFServer interface {
	Send(*PDFDocument) error
	grpc.ServerStream
}

type creditsServiceGetCreditUsageReportPDFServer struct {
	grpc.ServerStream
}

func (x *creditsServiceGetCreditUsageReportPDFServer) Send(m *PDFDocument) error {
	return x.ServerStream.SendMsg(m)
}

func _CreditsService_GetCreditBundleUsageProjection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCreditBundleUsageProjectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreditsServiceServer).GetCreditBundleUsageProjection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/arangodb.cloud.credits.v1.CreditsService/GetCreditBundleUsageProjection",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreditsServiceServer).GetCreditBundleUsageProjection(ctx, req.(*GetCreditBundleUsageProjectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CreditsService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "arangodb.cloud.credits.v1.CreditsService",
	HandlerType: (*CreditsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAPIVersion",
			Handler:    _CreditsService_GetAPIVersion_Handler,
		},
		{
			MethodName: "ListCreditBundles",
			Handler:    _CreditsService_ListCreditBundles_Handler,
		},
		{
			MethodName: "ListCreditBundlesUsage",
			Handler:    _CreditsService_ListCreditBundlesUsage_Handler,
		},
		{
			MethodName: "ListCreditUsageReports",
			Handler:    _CreditsService_ListCreditUsageReports_Handler,
		},
		{
			MethodName: "GetCreditUsageReport",
			Handler:    _CreditsService_GetCreditUsageReport_Handler,
		},
		{
			MethodName: "GetCreditBundleUsageProjection",
			Handler:    _CreditsService_GetCreditBundleUsageProjection_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetCreditUsageReportPDF",
			Handler:       _CreditsService_GetCreditUsageReportPDF_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "credits.proto",
}

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

func (m *CreditBundleUsageProjection) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundleUsageProjection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Projections) > 0 {
		for iNdEx := len(m.Projections) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Projections[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCredits(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditBundleUsageProjection_Projection) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundleUsageProjection_Projection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Value != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Value))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

func (m *GetCreditBundleUsageProjectionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetCreditBundleUsageProjectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ProjectionsLimit != 0 {
		i = encodeVarintCredits(dAtA, i, uint64(m.ProjectionsLimit))
		i--
		dAtA[i] = 0x10
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditUsageReportList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditUsageReportList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCredits(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ListCreditUsageReportsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListCreditUsageReportsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Options != nil {
		{
			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.To != nil {
		{
			size, err := m.To.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.From != nil {
		{
			size, err := m.From.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditUsageReport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditUsageReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xc2
	}
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCredits(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.CreatedAt != nil {
		{
			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.ClosingBalance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.ClosingBalance))))
		i--
		dAtA[i] = 0x35
	}
	if m.OpeningBalance != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.OpeningBalance))))
		i--
		dAtA[i] = 0x2d
	}
	if m.Amount != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Amount))))
		i--
		dAtA[i] = 0x25
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditUsageReport_Item) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditUsageReport_Item) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Amount != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Amount))))
		i--
		dAtA[i] = 0x15
	}
	if len(m.CreditusageIds) > 0 {
		for iNdEx := len(m.CreditusageIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.CreditusageIds[iNdEx])
			copy(dAtA[i:], m.CreditusageIds[iNdEx])
			i = encodeVarintCredits(dAtA, i, uint64(len(m.CreditusageIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditUsageReport_Status) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditUsageReport_Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.IsComplete {
		i--
		if m.IsComplete {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *PDFDocument) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PDFDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Filename) > 0 {
		i -= len(m.Filename)
		copy(dAtA[i:], m.Filename)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Filename)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Contents) > 0 {
		i -= len(m.Contents)
		copy(dAtA[i:], m.Contents)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Contents)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ListCreditBundleUsageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListCreditBundleUsageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Options != nil {
		{
			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.UsageItemId) > 0 {
		i -= len(m.UsageItemId)
		copy(dAtA[i:], m.UsageItemId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.UsageItemId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.EndsAt != nil {
		{
			size, err := m.EndsAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.StartsAt != nil {
		{
			size, err := m.StartsAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.CreditBundleId) > 0 {
		i -= len(m.CreditBundleId)
		copy(dAtA[i:], m.CreditBundleId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.CreditBundleId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ListCreditBundlesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListCreditBundlesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ExcludeExpired {
		i--
		if m.ExcludeExpired {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditBundlesList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundlesList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCredits(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditBundle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.LastUsedAt != nil {
		{
			size, err := m.LastUsedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.ValidUntil != nil {
		{
			size, err := m.ValidUntil.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.ValidFrom != nil {
		{
			size, err := m.ValidFrom.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.PurchasedAt != nil {
		{
			size, err := m.PurchasedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.CreditsRemaining != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CreditsRemaining))))
		i--
		dAtA[i] = 0x45
	}
	if len(m.Currency) > 0 {
		i -= len(m.Currency)
		copy(dAtA[i:], m.Currency)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Currency)))
		i--
		dAtA[i] = 0x3a
	}
	if m.TotalPrice != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.TotalPrice))))
		i--
		dAtA[i] = 0x35
	}
	if m.CreditsPurchased != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CreditsPurchased))))
		i--
		dAtA[i] = 0x2d
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditBundleUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundleUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CreatedAt != nil {
		{
			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCredits(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Remaining != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Remaining))))
		i--
		dAtA[i] = 0x35
	}
	if m.Usage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Usage))))
		i--
		dAtA[i] = 0x2d
	}
	if len(m.OrganizationId) > 0 {
		i -= len(m.OrganizationId)
		copy(dAtA[i:], m.OrganizationId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.OrganizationId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.CreditBundleId) > 0 {
		i -= len(m.CreditBundleId)
		copy(dAtA[i:], m.CreditBundleId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.CreditBundleId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.UsageItemId) > 0 {
		i -= len(m.UsageItemId)
		copy(dAtA[i:], m.UsageItemId)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.UsageItemId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCredits(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreditBundleUsageList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreditBundleUsageList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCredits(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintCredits(dAtA []byte, offset int, v uint64) int {
	offset -= sovCredits(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CreditBundleUsageProjection) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Projections) > 0 {
		for _, e := range m.Projections {
			l = e.Size()
			n += 1 + l + sovCredits(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreditBundleUsageProjection_Projection) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 5
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetCreditBundleUsageProjectionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.ProjectionsLimit != 0 {
		n += 1 + sovCredits(uint64(m.ProjectionsLimit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ListCreditUsageReportsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.From != nil {
		l = m.From.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.To != nil {
		l = m.To.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.Options != nil {
		l = m.Options.Size()
		n += 2 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreditUsageReport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.Amount != 0 {
		n += 5
	}
	if m.OpeningBalance != 0 {
		n += 5
	}
	if m.ClosingBalance != 0 {
		n += 5
	}
	if m.CreatedAt != nil {
		l = m.CreatedAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 2 + l + sovCredits(uint64(l))
		}
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 2 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreditUsageReport_Item) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.CreditusageIds) > 0 {
		for _, s := range m.CreditusageIds {
			l = len(s)
			n += 1 + l + sovCredits(uint64(l))
		}
	}
	if m.Amount != 0 {
		n += 5
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreditUsageReport_Status) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsComplete {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PDFDocument) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contents)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.Filename)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListCreditBundleUsageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.CreditBundleId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.StartsAt != nil {
		l = m.StartsAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.EndsAt != nil {
		l = m.EndsAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.UsageItemId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.Options != nil {
		l = m.Options.Size()
		n += 2 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListCreditBundlesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.ExcludeExpired {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *CreditBundle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.CreditsPurchased != 0 {
		n += 5
	}
	if m.TotalPrice != 0 {
		n += 5
	}
	l = len(m.Currency)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.CreditsRemaining != 0 {
		n += 5
	}
	if m.PurchasedAt != nil {
		l = m.PurchasedAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.ValidFrom != nil {
		l = m.ValidFrom.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.ValidUntil != nil {
		l = m.ValidUntil.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.LastUsedAt != nil {
		l = m.LastUsedAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreditBundleUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.UsageItemId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.CreditBundleId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	l = len(m.OrganizationId)
	if l > 0 {
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.Usage != 0 {
		n += 5
	}
	if m.Remaining != 0 {
		n += 5
	}
	if m.CreatedAt != nil {
		l = m.CreatedAt.Size()
		n += 1 + l + sovCredits(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovCredits(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCredits(x uint64) (n int) {
	return sovCredits(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CreditBundleUsageProjection) 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 ErrIntOverflowCredits
			}
			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: CreditBundleUsageProjection: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditBundleUsageProjection: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Projections", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Projections = append(m.Projections, &CreditBundleUsageProjection_Projection{})
			if err := m.Projections[len(m.Projections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditBundleUsageProjection_Projection) 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 ErrIntOverflowCredits
			}
			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: Projection: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Projection: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Value = float32(math.Float32frombits(v))
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *GetCreditBundleUsageProjectionRequest) 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 ErrIntOverflowCredits
			}
			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: GetCreditBundleUsageProjectionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetCreditBundleUsageProjectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProjectionsLimit", wireType)
			}
			m.ProjectionsLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProjectionsLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditUsageReportList) 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 ErrIntOverflowCredits
			}
			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: CreditUsageReportList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditUsageReportList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &CreditUsageReport{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *ListCreditUsageReportsRequest) 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 ErrIntOverflowCredits
			}
			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: ListCreditUsageReportsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListCreditUsageReportsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.From == nil {
				m.From = &types.Timestamp{}
			}
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.To == nil {
				m.To = &types.Timestamp{}
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Options == nil {
				m.Options = &v1.ListOptions{}
			}
			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditUsageReport) 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 ErrIntOverflowCredits
			}
			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: CreditUsageReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditUsageReport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Amount = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpeningBalance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.OpeningBalance = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClosingBalance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.ClosingBalance = float32(math.Float32frombits(v))
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = &types.Timestamp{}
			}
			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 100:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &CreditUsageReport_Item{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 200:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &CreditUsageReport_Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditUsageReport_Item) 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 ErrIntOverflowCredits
			}
			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: Item: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Item: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditusageIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreditusageIds = append(m.CreditusageIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Amount = float32(math.Float32frombits(v))
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditUsageReport_Status) 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 ErrIntOverflowCredits
			}
			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: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsComplete", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsComplete = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *PDFDocument) 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 ErrIntOverflowCredits
			}
			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: PDFDocument: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PDFDocument: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contents", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contents = append(m.Contents[:0], dAtA[iNdEx:postIndex]...)
			if m.Contents == nil {
				m.Contents = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *ListCreditBundleUsageRequest) 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 ErrIntOverflowCredits
			}
			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: ListCreditBundleUsageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListCreditBundleUsageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditBundleId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreditBundleId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartsAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StartsAt == nil {
				m.StartsAt = &types.Timestamp{}
			}
			if err := m.StartsAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndsAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndsAt == nil {
				m.EndsAt = &types.Timestamp{}
			}
			if err := m.EndsAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsageItemId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UsageItemId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Options == nil {
				m.Options = &v1.ListOptions{}
			}
			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *ListCreditBundlesRequest) 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 ErrIntOverflowCredits
			}
			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: ListCreditBundlesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListCreditBundlesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowCredits
				}
				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 := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditBundlesList) 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 ErrIntOverflowCredits
			}
			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: CreditBundlesList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditBundlesList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &CreditBundle{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditBundle) 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 ErrIntOverflowCredits
			}
			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: CreditBundle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditBundle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditsPurchased", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CreditsPurchased = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalPrice", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.TotalPrice = float32(math.Float32frombits(v))
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Currency", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Currency = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditsRemaining", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CreditsRemaining = float32(math.Float32frombits(v))
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PurchasedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PurchasedAt == nil {
				m.PurchasedAt = &types.Timestamp{}
			}
			if err := m.PurchasedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidFrom", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidFrom == nil {
				m.ValidFrom = &types.Timestamp{}
			}
			if err := m.ValidFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidUntil", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidUntil == nil {
				m.ValidUntil = &types.Timestamp{}
			}
			if err := m.ValidUntil.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUsedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastUsedAt == nil {
				m.LastUsedAt = &types.Timestamp{}
			}
			if err := m.LastUsedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditBundleUsage) 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 ErrIntOverflowCredits
			}
			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: CreditBundleUsage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditBundleUsage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsageItemId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UsageItemId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreditBundleId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreditBundleId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				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 ErrInvalidLengthCredits
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrganizationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Usage = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remaining", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Remaining = float32(math.Float32frombits(v))
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = &types.Timestamp{}
			}
			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 *CreditBundleUsageList) 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 ErrIntOverflowCredits
			}
			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: CreditBundleUsageList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreditBundleUsageList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCredits
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCredits
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &CreditBundleUsage{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCredits(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCredits
			}
			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 skipCredits(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCredits
			}
			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, ErrIntOverflowCredits
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCredits
				}
				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, ErrInvalidLengthCredits
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCredits
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCredits
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCredits        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCredits          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCredits = fmt.Errorf("proto: unexpected end of group")
)