audit.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: audit.proto

package protocol

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type EgressProtocol int32

const (
	EgressProtocol_IP_TCP EgressProtocol = 0
	EgressProtocol_IP_UDP EgressProtocol = 1
)

// Enum value maps for EgressProtocol.
var (
	EgressProtocol_name = map[int32]string{
		0: "IP_TCP",
		1: "IP_UDP",
	}
	EgressProtocol_value = map[string]int32{
		"IP_TCP": 0,
		"IP_UDP": 1,
	}
)

func (x EgressProtocol) Enum() *EgressProtocol {
	p := new(EgressProtocol)
	*p = x
	return p
}

func (x EgressProtocol) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (EgressProtocol) Descriptor() protoreflect.EnumDescriptor {
	return file_audit_proto_enumTypes[0].Descriptor()
}

func (EgressProtocol) Type() protoreflect.EnumType {
	return &file_audit_proto_enumTypes[0]
}

func (x EgressProtocol) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use EgressProtocol.Descriptor instead.
func (EgressProtocol) EnumDescriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{0}
}

// this is sent to the platform
// note the platform does not have prior knowledge and would have to brute force decrypt the audit record
// the provider creates and encrypts the final `AccountRecord` from the partial and discards the partial
type ProviderAudit struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Egress *EncryptedEgressRecord `protobuf:"bytes,1,opt,name=Egress,proto3" json:"Egress,omitempty"`
	// this data is used to encode the associated `AccountRecord`
	// this data is not stored and should be thrown out by the platform
	AccountPartial *AccountRecordPartial `protobuf:"bytes,2,opt,name=AccountPartial,proto3" json:"AccountPartial,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *ProviderAudit) Reset() {
	*x = ProviderAudit{}
	mi := &file_audit_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProviderAudit) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProviderAudit) ProtoMessage() {}

func (x *ProviderAudit) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProviderAudit.ProtoReflect.Descriptor instead.
func (*ProviderAudit) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{0}
}

func (x *ProviderAudit) GetEgress() *EncryptedEgressRecord {
	if x != nil {
		return x.Egress
	}
	return nil
}

func (x *ProviderAudit) GetAccountPartial() *AccountRecordPartial {
	if x != nil {
		return x.AccountPartial
	}
	return nil
}

// kept local on provider
// time block is UTC in 50ms blocks
// a typical abuse report will have to account for +-60s, or look up about 1200 blocks per record
type EgressKey struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	TimeBlock       uint64                 `protobuf:"varint,1,opt,name=TimeBlock,proto3" json:"TimeBlock,omitempty"`
	Protocol        EgressProtocol         `protobuf:"varint,2,opt,name=Protocol,proto3,enum=bringyour.EgressProtocol" json:"Protocol,omitempty"`
	SourceIp        []byte                 `protobuf:"bytes,3,opt,name=SourceIp,proto3" json:"SourceIp,omitempty"`
	SourcePort      uint32                 `protobuf:"varint,4,opt,name=SourcePort,proto3" json:"SourcePort,omitempty"`
	DestinationIp   []byte                 `protobuf:"bytes,5,opt,name=DestinationIp,proto3" json:"DestinationIp,omitempty"`
	DestinationPort uint32                 `protobuf:"varint,6,opt,name=DestinationPort,proto3" json:"DestinationPort,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *EgressKey) Reset() {
	*x = EgressKey{}
	mi := &file_audit_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EgressKey) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EgressKey) ProtoMessage() {}

func (x *EgressKey) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EgressKey.ProtoReflect.Descriptor instead.
func (*EgressKey) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{1}
}

func (x *EgressKey) GetTimeBlock() uint64 {
	if x != nil {
		return x.TimeBlock
	}
	return 0
}

func (x *EgressKey) GetProtocol() EgressProtocol {
	if x != nil {
		return x.Protocol
	}
	return EgressProtocol_IP_TCP
}

func (x *EgressKey) GetSourceIp() []byte {
	if x != nil {
		return x.SourceIp
	}
	return nil
}

func (x *EgressKey) GetSourcePort() uint32 {
	if x != nil {
		return x.SourcePort
	}
	return 0
}

func (x *EgressKey) GetDestinationIp() []byte {
	if x != nil {
		return x.DestinationIp
	}
	return nil
}

func (x *EgressKey) GetDestinationPort() uint32 {
	if x != nil {
		return x.DestinationPort
	}
	return 0
}

// kept local on provider
type EgressKeyWithSalt struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Key   *EgressKey             `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	// 128-bit
	Salt          []byte `protobuf:"bytes,2,opt,name=Salt,proto3" json:"Salt,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EgressKeyWithSalt) Reset() {
	*x = EgressKeyWithSalt{}
	mi := &file_audit_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EgressKeyWithSalt) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EgressKeyWithSalt) ProtoMessage() {}

func (x *EgressKeyWithSalt) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EgressKeyWithSalt.ProtoReflect.Descriptor instead.
func (*EgressKeyWithSalt) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{2}
}

func (x *EgressKeyWithSalt) GetKey() *EgressKey {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *EgressKeyWithSalt) GetSalt() []byte {
	if x != nil {
		return x.Salt
	}
	return nil
}

// this created on the provider so that the platform cannot see the raw data
// a complete audit record is an `EgressRecord` and an `AccountRecord`
type EncryptedEgressRecord struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// 128-bit
	Salt []byte `protobuf:"bytes,1,opt,name=Salt,proto3" json:"Salt,omitempty"`
	// Argon2id of `EgressKeyWithSalt`
	KeyWithSaltHash []byte `protobuf:"bytes,2,opt,name=KeyWithSaltHash,proto3" json:"KeyWithSaltHash,omitempty"`
	// AES256 using `EgressRecordSecret`
	EncryptedEgress []byte `protobuf:"bytes,3,opt,name=EncryptedEgress,proto3" json:"EncryptedEgress,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *EncryptedEgressRecord) Reset() {
	*x = EncryptedEgressRecord{}
	mi := &file_audit_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EncryptedEgressRecord) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EncryptedEgressRecord) ProtoMessage() {}

func (x *EncryptedEgressRecord) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EncryptedEgressRecord.ProtoReflect.Descriptor instead.
func (*EncryptedEgressRecord) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{3}
}

func (x *EncryptedEgressRecord) GetSalt() []byte {
	if x != nil {
		return x.Salt
	}
	return nil
}

func (x *EncryptedEgressRecord) GetKeyWithSaltHash() []byte {
	if x != nil {
		return x.KeyWithSaltHash
	}
	return nil
}

func (x *EncryptedEgressRecord) GetEncryptedEgress() []byte {
	if x != nil {
		return x.EncryptedEgress
	}
	return nil
}

type AccountRecordPartial struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// ulid
	ContractId          []byte `protobuf:"bytes,4,opt,name=ContractId,proto3" json:"ContractId,omitempty"`
	AccountRecordSecret []byte `protobuf:"bytes,5,opt,name=AccountRecordSecret,proto3" json:"AccountRecordSecret,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *AccountRecordPartial) Reset() {
	*x = AccountRecordPartial{}
	mi := &file_audit_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AccountRecordPartial) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AccountRecordPartial) ProtoMessage() {}

func (x *AccountRecordPartial) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AccountRecordPartial.ProtoReflect.Descriptor instead.
func (*AccountRecordPartial) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{4}
}

func (x *AccountRecordPartial) GetContractId() []byte {
	if x != nil {
		return x.ContractId
	}
	return nil
}

func (x *AccountRecordPartial) GetAccountRecordSecret() []byte {
	if x != nil {
		return x.AccountRecordSecret
	}
	return nil
}

type EgressRecordSecret struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Key   *EgressKey             `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	// 128-bit
	Salt []byte `protobuf:"bytes,2,opt,name=Salt,proto3" json:"Salt,omitempty"`
	// 24-bit
	Nonce         []byte `protobuf:"bytes,3,opt,name=Nonce,proto3" json:"Nonce,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EgressRecordSecret) Reset() {
	*x = EgressRecordSecret{}
	mi := &file_audit_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EgressRecordSecret) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EgressRecordSecret) ProtoMessage() {}

func (x *EgressRecordSecret) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EgressRecordSecret.ProtoReflect.Descriptor instead.
func (*EgressRecordSecret) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{5}
}

func (x *EgressRecordSecret) GetKey() *EgressKey {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *EgressRecordSecret) GetSalt() []byte {
	if x != nil {
		return x.Salt
	}
	return nil
}

func (x *EgressRecordSecret) GetNonce() []byte {
	if x != nil {
		return x.Nonce
	}
	return nil
}

type EgressRecord struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	Key                 *EgressKey             `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	StartTime           uint64                 `protobuf:"varint,2,opt,name=StartTime,proto3" json:"StartTime,omitempty"`
	EndTime             *uint64                `protobuf:"varint,3,opt,name=EndTime,proto3,oneof" json:"EndTime,omitempty"`
	AccountRecordSecret []byte                 `protobuf:"bytes,4,opt,name=AccountRecordSecret,proto3" json:"AccountRecordSecret,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *EgressRecord) Reset() {
	*x = EgressRecord{}
	mi := &file_audit_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EgressRecord) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EgressRecord) ProtoMessage() {}

func (x *EgressRecord) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EgressRecord.ProtoReflect.Descriptor instead.
func (*EgressRecord) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{6}
}

func (x *EgressRecord) GetKey() *EgressKey {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *EgressRecord) GetStartTime() uint64 {
	if x != nil {
		return x.StartTime
	}
	return 0
}

func (x *EgressRecord) GetEndTime() uint64 {
	if x != nil && x.EndTime != nil {
		return *x.EndTime
	}
	return 0
}

func (x *EgressRecord) GetAccountRecordSecret() []byte {
	if x != nil {
		return x.AccountRecordSecret
	}
	return nil
}

type AccountRecord struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// ulid
	ContractId []byte `protobuf:"bytes,1,opt,name=ContractId,proto3" json:"ContractId,omitempty"`
	// ulid
	ClientAccountId []byte `protobuf:"bytes,2,opt,name=ClientAccountId,proto3" json:"ClientAccountId,omitempty"`
	// ulid
	ProviderAccountId []byte `protobuf:"bytes,3,opt,name=ProviderAccountId,proto3" json:"ProviderAccountId,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *AccountRecord) Reset() {
	*x = AccountRecord{}
	mi := &file_audit_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AccountRecord) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AccountRecord) ProtoMessage() {}

func (x *AccountRecord) ProtoReflect() protoreflect.Message {
	mi := &file_audit_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AccountRecord.ProtoReflect.Descriptor instead.
func (*AccountRecord) Descriptor() ([]byte, []int) {
	return file_audit_proto_rawDescGZIP(), []int{7}
}

func (x *AccountRecord) GetContractId() []byte {
	if x != nil {
		return x.ContractId
	}
	return nil
}

func (x *AccountRecord) GetClientAccountId() []byte {
	if x != nil {
		return x.ClientAccountId
	}
	return nil
}

func (x *AccountRecord) GetProviderAccountId() []byte {
	if x != nil {
		return x.ProviderAccountId
	}
	return nil
}

var File_audit_proto protoreflect.FileDescriptor

const file_audit_proto_rawDesc = "" +
	"\n" +
	"\vaudit.proto\x12\tbringyour\"\x92\x01\n" +
	"\rProviderAudit\x128\n" +
	"\x06Egress\x18\x01 \x01(\v2 .bringyour.EncryptedEgressRecordR\x06Egress\x12G\n" +
	"\x0eAccountPartial\x18\x02 \x01(\v2\x1f.bringyour.AccountRecordPartialR\x0eAccountPartial\"\xec\x01\n" +
	"\tEgressKey\x12\x1c\n" +
	"\tTimeBlock\x18\x01 \x01(\x04R\tTimeBlock\x125\n" +
	"\bProtocol\x18\x02 \x01(\x0e2\x19.bringyour.EgressProtocolR\bProtocol\x12\x1a\n" +
	"\bSourceIp\x18\x03 \x01(\fR\bSourceIp\x12\x1e\n" +
	"\n" +
	"SourcePort\x18\x04 \x01(\rR\n" +
	"SourcePort\x12$\n" +
	"\rDestinationIp\x18\x05 \x01(\fR\rDestinationIp\x12(\n" +
	"\x0fDestinationPort\x18\x06 \x01(\rR\x0fDestinationPort\"O\n" +
	"\x11EgressKeyWithSalt\x12&\n" +
	"\x03Key\x18\x01 \x01(\v2\x14.bringyour.EgressKeyR\x03Key\x12\x12\n" +
	"\x04Salt\x18\x02 \x01(\fR\x04Salt\"\x7f\n" +
	"\x15EncryptedEgressRecord\x12\x12\n" +
	"\x04Salt\x18\x01 \x01(\fR\x04Salt\x12(\n" +
	"\x0fKeyWithSaltHash\x18\x02 \x01(\fR\x0fKeyWithSaltHash\x12(\n" +
	"\x0fEncryptedEgress\x18\x03 \x01(\fR\x0fEncryptedEgress\"h\n" +
	"\x14AccountRecordPartial\x12\x1e\n" +
	"\n" +
	"ContractId\x18\x04 \x01(\fR\n" +
	"ContractId\x120\n" +
	"\x13AccountRecordSecret\x18\x05 \x01(\fR\x13AccountRecordSecret\"f\n" +
	"\x12EgressRecordSecret\x12&\n" +
	"\x03Key\x18\x01 \x01(\v2\x14.bringyour.EgressKeyR\x03Key\x12\x12\n" +
	"\x04Salt\x18\x02 \x01(\fR\x04Salt\x12\x14\n" +
	"\x05Nonce\x18\x03 \x01(\fR\x05Nonce\"\xb1\x01\n" +
	"\fEgressRecord\x12&\n" +
	"\x03Key\x18\x01 \x01(\v2\x14.bringyour.EgressKeyR\x03Key\x12\x1c\n" +
	"\tStartTime\x18\x02 \x01(\x04R\tStartTime\x12\x1d\n" +
	"\aEndTime\x18\x03 \x01(\x04H\x00R\aEndTime\x88\x01\x01\x120\n" +
	"\x13AccountRecordSecret\x18\x04 \x01(\fR\x13AccountRecordSecretB\n" +
	"\n" +
	"\b_EndTime\"\x87\x01\n" +
	"\rAccountRecord\x12\x1e\n" +
	"\n" +
	"ContractId\x18\x01 \x01(\fR\n" +
	"ContractId\x12(\n" +
	"\x0fClientAccountId\x18\x02 \x01(\fR\x0fClientAccountId\x12,\n" +
	"\x11ProviderAccountId\x18\x03 \x01(\fR\x11ProviderAccountId*(\n" +
	"\x0eEgressProtocol\x12\n" +
	"\n" +
	"\x06IP_TCP\x10\x00\x12\n" +
	"\n" +
	"\x06IP_UDP\x10\x01B'Z%github.com/urnetwork/connect/protocolb\x06proto3"

var (
	file_audit_proto_rawDescOnce sync.Once
	file_audit_proto_rawDescData []byte
)

func file_audit_proto_rawDescGZIP() []byte {
	file_audit_proto_rawDescOnce.Do(func() {
		file_audit_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_audit_proto_rawDesc), len(file_audit_proto_rawDesc)))
	})
	return file_audit_proto_rawDescData
}

var file_audit_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_audit_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_audit_proto_goTypes = []any{
	(EgressProtocol)(0),           // 0: bringyour.EgressProtocol
	(*ProviderAudit)(nil),         // 1: bringyour.ProviderAudit
	(*EgressKey)(nil),             // 2: bringyour.EgressKey
	(*EgressKeyWithSalt)(nil),     // 3: bringyour.EgressKeyWithSalt
	(*EncryptedEgressRecord)(nil), // 4: bringyour.EncryptedEgressRecord
	(*AccountRecordPartial)(nil),  // 5: bringyour.AccountRecordPartial
	(*EgressRecordSecret)(nil),    // 6: bringyour.EgressRecordSecret
	(*EgressRecord)(nil),          // 7: bringyour.EgressRecord
	(*AccountRecord)(nil),         // 8: bringyour.AccountRecord
}
var file_audit_proto_depIdxs = []int32{
	4, // 0: bringyour.ProviderAudit.Egress:type_name -> bringyour.EncryptedEgressRecord
	5, // 1: bringyour.ProviderAudit.AccountPartial:type_name -> bringyour.AccountRecordPartial
	0, // 2: bringyour.EgressKey.Protocol:type_name -> bringyour.EgressProtocol
	2, // 3: bringyour.EgressKeyWithSalt.Key:type_name -> bringyour.EgressKey
	2, // 4: bringyour.EgressRecordSecret.Key:type_name -> bringyour.EgressKey
	2, // 5: bringyour.EgressRecord.Key:type_name -> bringyour.EgressKey
	6, // [6:6] is the sub-list for method output_type
	6, // [6:6] is the sub-list for method input_type
	6, // [6:6] is the sub-list for extension type_name
	6, // [6:6] is the sub-list for extension extendee
	0, // [0:6] is the sub-list for field type_name
}

func init() { file_audit_proto_init() }
func file_audit_proto_init() {
	if File_audit_proto != nil {
		return
	}
	file_audit_proto_msgTypes[6].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_audit_proto_rawDesc), len(file_audit_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_audit_proto_goTypes,
		DependencyIndexes: file_audit_proto_depIdxs,
		EnumInfos:         file_audit_proto_enumTypes,
		MessageInfos:      file_audit_proto_msgTypes,
	}.Build()
	File_audit_proto = out.File
	file_audit_proto_goTypes = nil
	file_audit_proto_depIdxs = nil
}