message.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: api/account/v1/message.proto

package account

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
	v1 "github.com/temporalio/tcld/protogen/api/sink/v1"
)

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

type State int32

const (
	STATE_UNSPECIFIED       State = 0
	STATE_ACTIVATING        State = 1
	STATE_ACTIVATION_FAILED State = 2
	STATE_ACTIVE            State = 3
	STATE_UPDATING          State = 4
	STATE_UPDATE_FAILED     State = 5
	STATE_DELETING          State = 6
	STATE_DELETE_FAILED     State = 7
	STATE_DELETED           State = 8
	STATE_SUSPENDING        State = 9
	STATE_SUSPEND_FAILED    State = 10
	STATE_SUSPENDED         State = 11
)

var State_name = map[int32]string{
	0:  "Unspecified",
	1:  "Activating",
	2:  "ActivationFailed",
	3:  "Active",
	4:  "Updating",
	5:  "UpdateFailed",
	6:  "Deleting",
	7:  "DeleteFailed",
	8:  "Deleted",
	9:  "Suspending",
	10: "SuspendFailed",
	11: "Suspended",
}

var State_value = map[string]int32{
	"Unspecified":      0,
	"Activating":       1,
	"ActivationFailed": 2,
	"Active":           3,
	"Updating":         4,
	"UpdateFailed":     5,
	"Deleting":         6,
	"DeleteFailed":     7,
	"Deleted":          8,
	"Suspending":       9,
	"SuspendFailed":    10,
	"Suspended":        11,
}

func (State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{0}
}

type Period int32

const (
	PERIOD_UNSPECIFIED Period = 0
	PERIOD_DAY         Period = 1
)

var Period_name = map[int32]string{
	0: "Unspecified",
	1: "Day",
}

var Period_value = map[string]int32{
	"Unspecified": 0,
	"Day":         1,
}

func (Period) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{1}
}

type MeteringRecord struct {
	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	Unit  string  `protobuf:"bytes,2,opt,name=unit,proto3" json:"unit,omitempty"`
}

func (m *MeteringRecord) Reset()      { *m = MeteringRecord{} }
func (*MeteringRecord) ProtoMessage() {}
func (*MeteringRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{0}
}
func (m *MeteringRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeteringRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeteringRecord.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 *MeteringRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeteringRecord.Merge(m, src)
}
func (m *MeteringRecord) XXX_Size() int {
	return m.Size()
}
func (m *MeteringRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_MeteringRecord.DiscardUnknown(m)
}

var xxx_messageInfo_MeteringRecord proto.InternalMessageInfo

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

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

type MeteringEntry struct {
	StartTime *types.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	EndTime   *types.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// The key is metering type.
	Records map[string]*MeteringRecord `protobuf:"bytes,3,rep,name=records,proto3" json:"records,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// The key is usage category (e.g. Activities, Workflows, Timers, etc.)
	UsageByCategory map[string]*MeteringRecord `protobuf:"bytes,4,rep,name=usage_by_category,json=usageByCategory,proto3" json:"usage_by_category,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *MeteringEntry) Reset()      { *m = MeteringEntry{} }
func (*MeteringEntry) ProtoMessage() {}
func (*MeteringEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{1}
}
func (m *MeteringEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeteringEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeteringEntry.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 *MeteringEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeteringEntry.Merge(m, src)
}
func (m *MeteringEntry) XXX_Size() int {
	return m.Size()
}
func (m *MeteringEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_MeteringEntry.DiscardUnknown(m)
}

var xxx_messageInfo_MeteringEntry proto.InternalMessageInfo

func (m *MeteringEntry) GetStartTime() *types.Timestamp {
	if m != nil {
		return m.StartTime
	}
	return nil
}

func (m *MeteringEntry) GetEndTime() *types.Timestamp {
	if m != nil {
		return m.EndTime
	}
	return nil
}

func (m *MeteringEntry) GetRecords() map[string]*MeteringRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *MeteringEntry) GetUsageByCategory() map[string]*MeteringRecord {
	if m != nil {
		return m.UsageByCategory
	}
	return nil
}

type NamespaceUsageRecord struct {
	// the namespace
	Namespace string         `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Entry     *MeteringEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
}

func (m *NamespaceUsageRecord) Reset()      { *m = NamespaceUsageRecord{} }
func (*NamespaceUsageRecord) ProtoMessage() {}
func (*NamespaceUsageRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{2}
}
func (m *NamespaceUsageRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NamespaceUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NamespaceUsageRecord.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 *NamespaceUsageRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NamespaceUsageRecord.Merge(m, src)
}
func (m *NamespaceUsageRecord) XXX_Size() int {
	return m.Size()
}
func (m *NamespaceUsageRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_NamespaceUsageRecord.DiscardUnknown(m)
}

var xxx_messageInfo_NamespaceUsageRecord proto.InternalMessageInfo

func (m *NamespaceUsageRecord) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *NamespaceUsageRecord) GetEntry() *MeteringEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type MetricsSpec struct {
	// enables the endpoint from which clients can scrape all their namespace metrics
	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// base64 encoded ca cert(s) used to authenticate clients connecting to the metrics endpoint
	AcceptedClientCa string `protobuf:"bytes,2,opt,name=accepted_client_ca,json=acceptedClientCa,proto3" json:"accepted_client_ca,omitempty"`
}

func (m *MetricsSpec) Reset()      { *m = MetricsSpec{} }
func (*MetricsSpec) ProtoMessage() {}
func (*MetricsSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{3}
}
func (m *MetricsSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetricsSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetricsSpec.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 *MetricsSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricsSpec.Merge(m, src)
}
func (m *MetricsSpec) XXX_Size() int {
	return m.Size()
}
func (m *MetricsSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricsSpec.DiscardUnknown(m)
}

var xxx_messageInfo_MetricsSpec proto.InternalMessageInfo

func (m *MetricsSpec) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *MetricsSpec) GetAcceptedClientCa() string {
	if m != nil {
		return m.AcceptedClientCa
	}
	return ""
}

type Metrics struct {
	// prometheus metrics endpoint uri (this is only populated if the AccountSpec has metrics enabled)
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
}

func (m *Metrics) Reset()      { *m = Metrics{} }
func (*Metrics) ProtoMessage() {}
func (*Metrics) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{4}
}
func (m *Metrics) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Metrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Metrics.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 *Metrics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metrics.Merge(m, src)
}
func (m *Metrics) XXX_Size() int {
	return m.Size()
}
func (m *Metrics) XXX_DiscardUnknown() {
	xxx_messageInfo_Metrics.DiscardUnknown(m)
}

var xxx_messageInfo_Metrics proto.InternalMessageInfo

func (m *Metrics) GetUri() string {
	if m != nil {
		return m.Uri
	}
	return ""
}

type AccountSpec struct {
	Metrics *MetricsSpec `protobuf:"bytes,1,opt,name=metrics,proto3" json:"metrics,omitempty"`
	// output sink specifications keyed on the sink name
	OutputSinks map[string]*v1.SinkSpec `protobuf:"bytes,3,rep,name=output_sinks,json=outputSinks,proto3" json:"output_sinks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *AccountSpec) Reset()      { *m = AccountSpec{} }
func (*AccountSpec) ProtoMessage() {}
func (*AccountSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{5}
}
func (m *AccountSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AccountSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AccountSpec.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 *AccountSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountSpec.Merge(m, src)
}
func (m *AccountSpec) XXX_Size() int {
	return m.Size()
}
func (m *AccountSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AccountSpec proto.InternalMessageInfo

func (m *AccountSpec) GetMetrics() *MetricsSpec {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *AccountSpec) GetOutputSinks() map[string]*v1.SinkSpec {
	if m != nil {
		return m.OutputSinks
	}
	return nil
}

type Account struct {
	// the current version of the account specification
	// the next update request will have to include this version
	ResourceVersion string `protobuf:"bytes,1,opt,name=resource_version,json=resourceVersion,proto3" json:"resource_version,omitempty"`
	// the account specification
	Spec *AccountSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	// the current state of the account
	State State `protobuf:"varint,3,opt,name=state,proto3,enum=api.account.v1.State" json:"state,omitempty"`
	// the id of the request that is creating/updating the account, if any
	RequestId string `protobuf:"bytes,4,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// the date and time when the account was created
	CreatedTime *types.Timestamp `protobuf:"bytes,5,opt,name=created_time,json=createdTime,proto3" json:"created_time,omitempty"`
	// the date and time when the account was last modified
	LastModifiedTime *types.Timestamp `protobuf:"bytes,6,opt,name=last_modified_time,json=lastModifiedTime,proto3" json:"last_modified_time,omitempty"`
	// information related to account-scope metrics
	Metrics *Metrics `protobuf:"bytes,7,opt,name=metrics,proto3" json:"metrics,omitempty"`
	// The external id we use for assuming role. Reference link
	// https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html
	AwsExternalId string `protobuf:"bytes,9,opt,name=aws_external_id,json=awsExternalId,proto3" json:"aws_external_id,omitempty"`
	// output sink definitions keyed on the sink name
	OutputSinks map[string]*v1.Sink `protobuf:"bytes,10,rep,name=output_sinks,json=outputSinks,proto3" json:"output_sinks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// GCP Sink Specific
	GcpSinkSettings *GCPSinkSettings `protobuf:"bytes,11,opt,name=gcp_sink_settings,json=gcpSinkSettings,proto3" json:"gcp_sink_settings,omitempty"`
}

func (m *Account) Reset()      { *m = Account{} }
func (*Account) ProtoMessage() {}
func (*Account) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{6}
}
func (m *Account) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Account) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Account.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 *Account) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Account.Merge(m, src)
}
func (m *Account) XXX_Size() int {
	return m.Size()
}
func (m *Account) XXX_DiscardUnknown() {
	xxx_messageInfo_Account.DiscardUnknown(m)
}

var xxx_messageInfo_Account proto.InternalMessageInfo

func (m *Account) GetResourceVersion() string {
	if m != nil {
		return m.ResourceVersion
	}
	return ""
}

func (m *Account) GetSpec() *AccountSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *Account) GetState() State {
	if m != nil {
		return m.State
	}
	return STATE_UNSPECIFIED
}

func (m *Account) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *Account) GetCreatedTime() *types.Timestamp {
	if m != nil {
		return m.CreatedTime
	}
	return nil
}

func (m *Account) GetLastModifiedTime() *types.Timestamp {
	if m != nil {
		return m.LastModifiedTime
	}
	return nil
}

func (m *Account) GetMetrics() *Metrics {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *Account) GetAwsExternalId() string {
	if m != nil {
		return m.AwsExternalId
	}
	return ""
}

func (m *Account) GetOutputSinks() map[string]*v1.Sink {
	if m != nil {
		return m.OutputSinks
	}
	return nil
}

func (m *Account) GetGcpSinkSettings() *GCPSinkSettings {
	if m != nil {
		return m.GcpSinkSettings
	}
	return nil
}

type GCPSinkSettings struct {
	ExportInternalServiceAccountEmails   []string `protobuf:"bytes,1,rep,name=export_internal_service_account_emails,json=exportInternalServiceAccountEmails,proto3" json:"export_internal_service_account_emails,omitempty"`
	AuditlogInternalServiceAccountEmails []string `protobuf:"bytes,2,rep,name=auditlog_internal_service_account_emails,json=auditlogInternalServiceAccountEmails,proto3" json:"auditlog_internal_service_account_emails,omitempty"`
}

func (m *GCPSinkSettings) Reset()      { *m = GCPSinkSettings{} }
func (*GCPSinkSettings) ProtoMessage() {}
func (*GCPSinkSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_603c66a56913ad55, []int{7}
}
func (m *GCPSinkSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GCPSinkSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GCPSinkSettings.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 *GCPSinkSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GCPSinkSettings.Merge(m, src)
}
func (m *GCPSinkSettings) XXX_Size() int {
	return m.Size()
}
func (m *GCPSinkSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_GCPSinkSettings.DiscardUnknown(m)
}

var xxx_messageInfo_GCPSinkSettings proto.InternalMessageInfo

func (m *GCPSinkSettings) GetExportInternalServiceAccountEmails() []string {
	if m != nil {
		return m.ExportInternalServiceAccountEmails
	}
	return nil
}

func (m *GCPSinkSettings) GetAuditlogInternalServiceAccountEmails() []string {
	if m != nil {
		return m.AuditlogInternalServiceAccountEmails
	}
	return nil
}

func init() {
	proto.RegisterEnum("api.account.v1.State", State_name, State_value)
	proto.RegisterEnum("api.account.v1.Period", Period_name, Period_value)
	proto.RegisterType((*MeteringRecord)(nil), "api.account.v1.MeteringRecord")
	proto.RegisterType((*MeteringEntry)(nil), "api.account.v1.MeteringEntry")
	proto.RegisterMapType((map[string]*MeteringRecord)(nil), "api.account.v1.MeteringEntry.RecordsEntry")
	proto.RegisterMapType((map[string]*MeteringRecord)(nil), "api.account.v1.MeteringEntry.UsageByCategoryEntry")
	proto.RegisterType((*NamespaceUsageRecord)(nil), "api.account.v1.NamespaceUsageRecord")
	proto.RegisterType((*MetricsSpec)(nil), "api.account.v1.MetricsSpec")
	proto.RegisterType((*Metrics)(nil), "api.account.v1.Metrics")
	proto.RegisterType((*AccountSpec)(nil), "api.account.v1.AccountSpec")
	proto.RegisterMapType((map[string]*v1.SinkSpec)(nil), "api.account.v1.AccountSpec.OutputSinksEntry")
	proto.RegisterType((*Account)(nil), "api.account.v1.Account")
	proto.RegisterMapType((map[string]*v1.Sink)(nil), "api.account.v1.Account.OutputSinksEntry")
	proto.RegisterType((*GCPSinkSettings)(nil), "api.account.v1.GCPSinkSettings")
}

func init() { proto.RegisterFile("api/account/v1/message.proto", fileDescriptor_603c66a56913ad55) }

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

func (x State) String() string {
	s, ok := State_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Period) String() string {
	s, ok := Period_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *MeteringRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MeteringRecord)
	if !ok {
		that2, ok := that.(MeteringRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if this.Unit != that1.Unit {
		return false
	}
	return true
}
func (this *MeteringEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MeteringEntry)
	if !ok {
		that2, ok := that.(MeteringEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.StartTime.Equal(that1.StartTime) {
		return false
	}
	if !this.EndTime.Equal(that1.EndTime) {
		return false
	}
	if len(this.Records) != len(that1.Records) {
		return false
	}
	for i := range this.Records {
		if !this.Records[i].Equal(that1.Records[i]) {
			return false
		}
	}
	if len(this.UsageByCategory) != len(that1.UsageByCategory) {
		return false
	}
	for i := range this.UsageByCategory {
		if !this.UsageByCategory[i].Equal(that1.UsageByCategory[i]) {
			return false
		}
	}
	return true
}
func (this *NamespaceUsageRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NamespaceUsageRecord)
	if !ok {
		that2, ok := that.(NamespaceUsageRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if !this.Entry.Equal(that1.Entry) {
		return false
	}
	return true
}
func (this *MetricsSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetricsSpec)
	if !ok {
		that2, ok := that.(MetricsSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Enabled != that1.Enabled {
		return false
	}
	if this.AcceptedClientCa != that1.AcceptedClientCa {
		return false
	}
	return true
}
func (this *Metrics) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Metrics)
	if !ok {
		that2, ok := that.(Metrics)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Uri != that1.Uri {
		return false
	}
	return true
}
func (this *AccountSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AccountSpec)
	if !ok {
		that2, ok := that.(AccountSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metrics.Equal(that1.Metrics) {
		return false
	}
	if len(this.OutputSinks) != len(that1.OutputSinks) {
		return false
	}
	for i := range this.OutputSinks {
		if !this.OutputSinks[i].Equal(that1.OutputSinks[i]) {
			return false
		}
	}
	return true
}
func (this *Account) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Account)
	if !ok {
		that2, ok := that.(Account)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ResourceVersion != that1.ResourceVersion {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.RequestId != that1.RequestId {
		return false
	}
	if !this.CreatedTime.Equal(that1.CreatedTime) {
		return false
	}
	if !this.LastModifiedTime.Equal(that1.LastModifiedTime) {
		return false
	}
	if !this.Metrics.Equal(that1.Metrics) {
		return false
	}
	if this.AwsExternalId != that1.AwsExternalId {
		return false
	}
	if len(this.OutputSinks) != len(that1.OutputSinks) {
		return false
	}
	for i := range this.OutputSinks {
		if !this.OutputSinks[i].Equal(that1.OutputSinks[i]) {
			return false
		}
	}
	if !this.GcpSinkSettings.Equal(that1.GcpSinkSettings) {
		return false
	}
	return true
}
func (this *GCPSinkSettings) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GCPSinkSettings)
	if !ok {
		that2, ok := that.(GCPSinkSettings)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.ExportInternalServiceAccountEmails) != len(that1.ExportInternalServiceAccountEmails) {
		return false
	}
	for i := range this.ExportInternalServiceAccountEmails {
		if this.ExportInternalServiceAccountEmails[i] != that1.ExportInternalServiceAccountEmails[i] {
			return false
		}
	}
	if len(this.AuditlogInternalServiceAccountEmails) != len(that1.AuditlogInternalServiceAccountEmails) {
		return false
	}
	for i := range this.AuditlogInternalServiceAccountEmails {
		if this.AuditlogInternalServiceAccountEmails[i] != that1.AuditlogInternalServiceAccountEmails[i] {
			return false
		}
	}
	return true
}
func (this *MeteringRecord) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&account.MeteringRecord{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "Unit: "+fmt.Sprintf("%#v", this.Unit)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MeteringEntry) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&account.MeteringEntry{")
	if this.StartTime != nil {
		s = append(s, "StartTime: "+fmt.Sprintf("%#v", this.StartTime)+",\n")
	}
	if this.EndTime != nil {
		s = append(s, "EndTime: "+fmt.Sprintf("%#v", this.EndTime)+",\n")
	}
	keysForRecords := make([]string, 0, len(this.Records))
	for k, _ := range this.Records {
		keysForRecords = append(keysForRecords, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRecords)
	mapStringForRecords := "map[string]*MeteringRecord{"
	for _, k := range keysForRecords {
		mapStringForRecords += fmt.Sprintf("%#v: %#v,", k, this.Records[k])
	}
	mapStringForRecords += "}"
	if this.Records != nil {
		s = append(s, "Records: "+mapStringForRecords+",\n")
	}
	keysForUsageByCategory := make([]string, 0, len(this.UsageByCategory))
	for k, _ := range this.UsageByCategory {
		keysForUsageByCategory = append(keysForUsageByCategory, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForUsageByCategory)
	mapStringForUsageByCategory := "map[string]*MeteringRecord{"
	for _, k := range keysForUsageByCategory {
		mapStringForUsageByCategory += fmt.Sprintf("%#v: %#v,", k, this.UsageByCategory[k])
	}
	mapStringForUsageByCategory += "}"
	if this.UsageByCategory != nil {
		s = append(s, "UsageByCategory: "+mapStringForUsageByCategory+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NamespaceUsageRecord) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&account.NamespaceUsageRecord{")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	if this.Entry != nil {
		s = append(s, "Entry: "+fmt.Sprintf("%#v", this.Entry)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetricsSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&account.MetricsSpec{")
	s = append(s, "Enabled: "+fmt.Sprintf("%#v", this.Enabled)+",\n")
	s = append(s, "AcceptedClientCa: "+fmt.Sprintf("%#v", this.AcceptedClientCa)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Metrics) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&account.Metrics{")
	s = append(s, "Uri: "+fmt.Sprintf("%#v", this.Uri)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AccountSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&account.AccountSpec{")
	if this.Metrics != nil {
		s = append(s, "Metrics: "+fmt.Sprintf("%#v", this.Metrics)+",\n")
	}
	keysForOutputSinks := make([]string, 0, len(this.OutputSinks))
	for k, _ := range this.OutputSinks {
		keysForOutputSinks = append(keysForOutputSinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForOutputSinks)
	mapStringForOutputSinks := "map[string]*v1.SinkSpec{"
	for _, k := range keysForOutputSinks {
		mapStringForOutputSinks += fmt.Sprintf("%#v: %#v,", k, this.OutputSinks[k])
	}
	mapStringForOutputSinks += "}"
	if this.OutputSinks != nil {
		s = append(s, "OutputSinks: "+mapStringForOutputSinks+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Account) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&account.Account{")
	s = append(s, "ResourceVersion: "+fmt.Sprintf("%#v", this.ResourceVersion)+",\n")
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	s = append(s, "RequestId: "+fmt.Sprintf("%#v", this.RequestId)+",\n")
	if this.CreatedTime != nil {
		s = append(s, "CreatedTime: "+fmt.Sprintf("%#v", this.CreatedTime)+",\n")
	}
	if this.LastModifiedTime != nil {
		s = append(s, "LastModifiedTime: "+fmt.Sprintf("%#v", this.LastModifiedTime)+",\n")
	}
	if this.Metrics != nil {
		s = append(s, "Metrics: "+fmt.Sprintf("%#v", this.Metrics)+",\n")
	}
	s = append(s, "AwsExternalId: "+fmt.Sprintf("%#v", this.AwsExternalId)+",\n")
	keysForOutputSinks := make([]string, 0, len(this.OutputSinks))
	for k, _ := range this.OutputSinks {
		keysForOutputSinks = append(keysForOutputSinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForOutputSinks)
	mapStringForOutputSinks := "map[string]*v1.Sink{"
	for _, k := range keysForOutputSinks {
		mapStringForOutputSinks += fmt.Sprintf("%#v: %#v,", k, this.OutputSinks[k])
	}
	mapStringForOutputSinks += "}"
	if this.OutputSinks != nil {
		s = append(s, "OutputSinks: "+mapStringForOutputSinks+",\n")
	}
	if this.GcpSinkSettings != nil {
		s = append(s, "GcpSinkSettings: "+fmt.Sprintf("%#v", this.GcpSinkSettings)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GCPSinkSettings) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&account.GCPSinkSettings{")
	s = append(s, "ExportInternalServiceAccountEmails: "+fmt.Sprintf("%#v", this.ExportInternalServiceAccountEmails)+",\n")
	s = append(s, "AuditlogInternalServiceAccountEmails: "+fmt.Sprintf("%#v", this.AuditlogInternalServiceAccountEmails)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringMessage(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *MeteringRecord) 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 *MeteringRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeteringRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Unit) > 0 {
		i -= len(m.Unit)
		copy(dAtA[i:], m.Unit)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Unit)))
		i--
		dAtA[i] = 0x12
	}
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *MeteringEntry) 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 *MeteringEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeteringEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UsageByCategory) > 0 {
		for k := range m.UsageByCategory {
			v := m.UsageByCategory[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintMessage(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMessage(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMessage(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Records) > 0 {
		for k := range m.Records {
			v := m.Records[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintMessage(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMessage(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMessage(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.EndTime != nil {
		{
			size, err := m.EndTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.StartTime != nil {
		{
			size, err := m.StartTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NamespaceUsageRecord) 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 *NamespaceUsageRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NamespaceUsageRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MetricsSpec) 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 *MetricsSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetricsSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AcceptedClientCa) > 0 {
		i -= len(m.AcceptedClientCa)
		copy(dAtA[i:], m.AcceptedClientCa)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.AcceptedClientCa)))
		i--
		dAtA[i] = 0x12
	}
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Metrics) 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 *Metrics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Uri) > 0 {
		i -= len(m.Uri)
		copy(dAtA[i:], m.Uri)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Uri)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AccountSpec) 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 *AccountSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OutputSinks) > 0 {
		for k := range m.OutputSinks {
			v := m.OutputSinks[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintMessage(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMessage(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMessage(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Metrics != nil {
		{
			size, err := m.Metrics.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Account) 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 *Account) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Account) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GcpSinkSettings != nil {
		{
			size, err := m.GcpSinkSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if len(m.OutputSinks) > 0 {
		for k := range m.OutputSinks {
			v := m.OutputSinks[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintMessage(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMessage(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMessage(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.AwsExternalId) > 0 {
		i -= len(m.AwsExternalId)
		copy(dAtA[i:], m.AwsExternalId)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.AwsExternalId)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Metrics != nil {
		{
			size, err := m.Metrics.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.LastModifiedTime != nil {
		{
			size, err := m.LastModifiedTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.CreatedTime != nil {
		{
			size, err := m.CreatedTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.RequestId) > 0 {
		i -= len(m.RequestId)
		copy(dAtA[i:], m.RequestId)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.RequestId)))
		i--
		dAtA[i] = 0x22
	}
	if m.State != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ResourceVersion) > 0 {
		i -= len(m.ResourceVersion)
		copy(dAtA[i:], m.ResourceVersion)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.ResourceVersion)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GCPSinkSettings) 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 *GCPSinkSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GCPSinkSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AuditlogInternalServiceAccountEmails) > 0 {
		for iNdEx := len(m.AuditlogInternalServiceAccountEmails) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.AuditlogInternalServiceAccountEmails[iNdEx])
			copy(dAtA[i:], m.AuditlogInternalServiceAccountEmails[iNdEx])
			i = encodeVarintMessage(dAtA, i, uint64(len(m.AuditlogInternalServiceAccountEmails[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ExportInternalServiceAccountEmails) > 0 {
		for iNdEx := len(m.ExportInternalServiceAccountEmails) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ExportInternalServiceAccountEmails[iNdEx])
			copy(dAtA[i:], m.ExportInternalServiceAccountEmails[iNdEx])
			i = encodeVarintMessage(dAtA, i, uint64(len(m.ExportInternalServiceAccountEmails[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintMessage(dAtA []byte, offset int, v uint64) int {
	offset -= sovMessage(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MeteringRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 9
	}
	l = len(m.Unit)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *MeteringEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartTime != nil {
		l = m.StartTime.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.EndTime != nil {
		l = m.EndTime.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if len(m.Records) > 0 {
		for k, v := range m.Records {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovMessage(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovMessage(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovMessage(uint64(mapEntrySize))
		}
	}
	if len(m.UsageByCategory) > 0 {
		for k, v := range m.UsageByCategory {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovMessage(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovMessage(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovMessage(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *NamespaceUsageRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *MetricsSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enabled {
		n += 2
	}
	l = len(m.AcceptedClientCa)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Metrics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Uri)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

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

func (m *Account) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ResourceVersion)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovMessage(uint64(m.State))
	}
	l = len(m.RequestId)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.CreatedTime != nil {
		l = m.CreatedTime.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.LastModifiedTime != nil {
		l = m.LastModifiedTime.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.Metrics != nil {
		l = m.Metrics.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	l = len(m.AwsExternalId)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if len(m.OutputSinks) > 0 {
		for k, v := range m.OutputSinks {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovMessage(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovMessage(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovMessage(uint64(mapEntrySize))
		}
	}
	if m.GcpSinkSettings != nil {
		l = m.GcpSinkSettings.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *GCPSinkSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ExportInternalServiceAccountEmails) > 0 {
		for _, s := range m.ExportInternalServiceAccountEmails {
			l = len(s)
			n += 1 + l + sovMessage(uint64(l))
		}
	}
	if len(m.AuditlogInternalServiceAccountEmails) > 0 {
		for _, s := range m.AuditlogInternalServiceAccountEmails {
			l = len(s)
			n += 1 + l + sovMessage(uint64(l))
		}
	}
	return n
}

func sovMessage(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMessage(x uint64) (n int) {
	return sovMessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *MeteringRecord) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MeteringRecord{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`Unit:` + fmt.Sprintf("%v", this.Unit) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MeteringEntry) String() string {
	if this == nil {
		return "nil"
	}
	keysForRecords := make([]string, 0, len(this.Records))
	for k, _ := range this.Records {
		keysForRecords = append(keysForRecords, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRecords)
	mapStringForRecords := "map[string]*MeteringRecord{"
	for _, k := range keysForRecords {
		mapStringForRecords += fmt.Sprintf("%v: %v,", k, this.Records[k])
	}
	mapStringForRecords += "}"
	keysForUsageByCategory := make([]string, 0, len(this.UsageByCategory))
	for k, _ := range this.UsageByCategory {
		keysForUsageByCategory = append(keysForUsageByCategory, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForUsageByCategory)
	mapStringForUsageByCategory := "map[string]*MeteringRecord{"
	for _, k := range keysForUsageByCategory {
		mapStringForUsageByCategory += fmt.Sprintf("%v: %v,", k, this.UsageByCategory[k])
	}
	mapStringForUsageByCategory += "}"
	s := strings.Join([]string{`&MeteringEntry{`,
		`StartTime:` + strings.Replace(fmt.Sprintf("%v", this.StartTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`EndTime:` + strings.Replace(fmt.Sprintf("%v", this.EndTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`Records:` + mapStringForRecords + `,`,
		`UsageByCategory:` + mapStringForUsageByCategory + `,`,
		`}`,
	}, "")
	return s
}
func (this *NamespaceUsageRecord) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NamespaceUsageRecord{`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`Entry:` + strings.Replace(this.Entry.String(), "MeteringEntry", "MeteringEntry", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetricsSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetricsSpec{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`AcceptedClientCa:` + fmt.Sprintf("%v", this.AcceptedClientCa) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Metrics) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Metrics{`,
		`Uri:` + fmt.Sprintf("%v", this.Uri) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AccountSpec) String() string {
	if this == nil {
		return "nil"
	}
	keysForOutputSinks := make([]string, 0, len(this.OutputSinks))
	for k, _ := range this.OutputSinks {
		keysForOutputSinks = append(keysForOutputSinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForOutputSinks)
	mapStringForOutputSinks := "map[string]*v1.SinkSpec{"
	for _, k := range keysForOutputSinks {
		mapStringForOutputSinks += fmt.Sprintf("%v: %v,", k, this.OutputSinks[k])
	}
	mapStringForOutputSinks += "}"
	s := strings.Join([]string{`&AccountSpec{`,
		`Metrics:` + strings.Replace(this.Metrics.String(), "MetricsSpec", "MetricsSpec", 1) + `,`,
		`OutputSinks:` + mapStringForOutputSinks + `,`,
		`}`,
	}, "")
	return s
}
func (this *Account) String() string {
	if this == nil {
		return "nil"
	}
	keysForOutputSinks := make([]string, 0, len(this.OutputSinks))
	for k, _ := range this.OutputSinks {
		keysForOutputSinks = append(keysForOutputSinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForOutputSinks)
	mapStringForOutputSinks := "map[string]*v1.Sink{"
	for _, k := range keysForOutputSinks {
		mapStringForOutputSinks += fmt.Sprintf("%v: %v,", k, this.OutputSinks[k])
	}
	mapStringForOutputSinks += "}"
	s := strings.Join([]string{`&Account{`,
		`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "AccountSpec", "AccountSpec", 1) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`RequestId:` + fmt.Sprintf("%v", this.RequestId) + `,`,
		`CreatedTime:` + strings.Replace(fmt.Sprintf("%v", this.CreatedTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`LastModifiedTime:` + strings.Replace(fmt.Sprintf("%v", this.LastModifiedTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`Metrics:` + strings.Replace(this.Metrics.String(), "Metrics", "Metrics", 1) + `,`,
		`AwsExternalId:` + fmt.Sprintf("%v", this.AwsExternalId) + `,`,
		`OutputSinks:` + mapStringForOutputSinks + `,`,
		`GcpSinkSettings:` + strings.Replace(this.GcpSinkSettings.String(), "GCPSinkSettings", "GCPSinkSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GCPSinkSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GCPSinkSettings{`,
		`ExportInternalServiceAccountEmails:` + fmt.Sprintf("%v", this.ExportInternalServiceAccountEmails) + `,`,
		`AuditlogInternalServiceAccountEmails:` + fmt.Sprintf("%v", this.AuditlogInternalServiceAccountEmails) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMessage(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *MeteringRecord) 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 ErrIntOverflowMessage
			}
			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: MeteringRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeteringRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeteringEntry) 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 ErrIntOverflowMessage
			}
			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: MeteringEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeteringEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StartTime == nil {
				m.StartTime = &types.Timestamp{}
			}
			if err := m.StartTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndTime == nil {
				m.EndTime = &types.Timestamp{}
			}
			if err := m.EndTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Records == nil {
				m.Records = make(map[string]*MeteringRecord)
			}
			var mapkey string
			var mapvalue *MeteringRecord
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessage
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthMessage
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthMessage
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MeteringRecord{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMessage(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthMessage
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Records[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsageByCategory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UsageByCategory == nil {
				m.UsageByCategory = make(map[string]*MeteringRecord)
			}
			var mapkey string
			var mapvalue *MeteringRecord
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessage
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthMessage
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthMessage
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MeteringRecord{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMessage(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthMessage
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.UsageByCategory[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamespaceUsageRecord) 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 ErrIntOverflowMessage
			}
			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: NamespaceUsageRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamespaceUsageRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &MeteringEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricsSpec) 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 ErrIntOverflowMessage
			}
			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: MetricsSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricsSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptedClientCa", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AcceptedClientCa = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metrics) 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 ErrIntOverflowMessage
			}
			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: Metrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uri", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Uri = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountSpec) 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 ErrIntOverflowMessage
			}
			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: AccountSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metrics == nil {
				m.Metrics = &MetricsSpec{}
			}
			if err := m.Metrics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputSinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutputSinks == nil {
				m.OutputSinks = make(map[string]*v1.SinkSpec)
			}
			var mapkey string
			var mapvalue *v1.SinkSpec
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessage
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthMessage
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthMessage
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1.SinkSpec{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMessage(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthMessage
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.OutputSinks[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Account) 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 ErrIntOverflowMessage
			}
			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: Account: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Account: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &AccountSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedTime == nil {
				m.CreatedTime = &types.Timestamp{}
			}
			if err := m.CreatedTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastModifiedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastModifiedTime == nil {
				m.LastModifiedTime = &types.Timestamp{}
			}
			if err := m.LastModifiedTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metrics == nil {
				m.Metrics = &Metrics{}
			}
			if err := m.Metrics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AwsExternalId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AwsExternalId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputSinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutputSinks == nil {
				m.OutputSinks = make(map[string]*v1.Sink)
			}
			var mapkey string
			var mapvalue *v1.Sink
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessage
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMessage
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessage
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthMessage
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthMessage
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1.Sink{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMessage(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthMessage
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.OutputSinks[mapkey] = mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GcpSinkSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GcpSinkSettings == nil {
				m.GcpSinkSettings = &GCPSinkSettings{}
			}
			if err := m.GcpSinkSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GCPSinkSettings) 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 ErrIntOverflowMessage
			}
			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: GCPSinkSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GCPSinkSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExportInternalServiceAccountEmails", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExportInternalServiceAccountEmails = append(m.ExportInternalServiceAccountEmails, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuditlogInternalServiceAccountEmails", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuditlogInternalServiceAccountEmails = append(m.AuditlogInternalServiceAccountEmails, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMessage(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, ErrIntOverflowMessage
			}
			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, ErrIntOverflowMessage
				}
				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, ErrIntOverflowMessage
				}
				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, ErrInvalidLengthMessage
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMessage
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMessage
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMessage        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessage          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessage = fmt.Errorf("proto: unexpected end of group")
)