mirror of
https://dev.azure.com/schwarzit/schwarzit.stackit-public/_git/audit-go
synced 2026-02-18 13:42:01 +00:00
f2715624e9
The subject claim may contain underscore characters which are not allowed by the schema yet. Therefore, an adjustment of the regex in the schema has been made to allow it. Security-concept-update-needed: false. JIRA Work Item: STACKITALO-437
513 lines
16 KiB
Go
513 lines
16 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.9
|
|
// protoc (unknown)
|
|
// source: audit/v1/routable_event.proto
|
|
|
|
package auditV1
|
|
|
|
import (
|
|
_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
|
|
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 Visibility int32
|
|
|
|
const (
|
|
Visibility_VISIBILITY_UNSPECIFIED Visibility = 0
|
|
// Will be routed to customer data sinks
|
|
Visibility_VISIBILITY_PUBLIC Visibility = 1
|
|
// Will NOT be routed to customer data sinks
|
|
Visibility_VISIBILITY_PRIVATE Visibility = 2
|
|
)
|
|
|
|
// Enum value maps for Visibility.
|
|
var (
|
|
Visibility_name = map[int32]string{
|
|
0: "VISIBILITY_UNSPECIFIED",
|
|
1: "VISIBILITY_PUBLIC",
|
|
2: "VISIBILITY_PRIVATE",
|
|
}
|
|
Visibility_value = map[string]int32{
|
|
"VISIBILITY_UNSPECIFIED": 0,
|
|
"VISIBILITY_PUBLIC": 1,
|
|
"VISIBILITY_PRIVATE": 2,
|
|
}
|
|
)
|
|
|
|
func (x Visibility) Enum() *Visibility {
|
|
p := new(Visibility)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x Visibility) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (Visibility) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_audit_v1_routable_event_proto_enumTypes[0].Descriptor()
|
|
}
|
|
|
|
func (Visibility) Type() protoreflect.EnumType {
|
|
return &file_audit_v1_routable_event_proto_enumTypes[0]
|
|
}
|
|
|
|
func (x Visibility) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use Visibility.Descriptor instead.
|
|
func (Visibility) EnumDescriptor() ([]byte, []int) {
|
|
return file_audit_v1_routable_event_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
// Identifier of an object.
|
|
//
|
|
// For system events, the nil UUID must be used: 00000000-0000-0000-0000-000000000000.
|
|
type ObjectIdentifier struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Identifier of the respective entity (e.g. Identifier of an organization)
|
|
//
|
|
// Required: true
|
|
Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
|
|
// Entity data type relevant for routing - one of the list of supported object types.
|
|
//
|
|
// Required: true
|
|
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ObjectIdentifier) Reset() {
|
|
*x = ObjectIdentifier{}
|
|
mi := &file_audit_v1_routable_event_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ObjectIdentifier) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ObjectIdentifier) ProtoMessage() {}
|
|
|
|
func (x *ObjectIdentifier) ProtoReflect() protoreflect.Message {
|
|
mi := &file_audit_v1_routable_event_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 ObjectIdentifier.ProtoReflect.Descriptor instead.
|
|
func (*ObjectIdentifier) Descriptor() ([]byte, []int) {
|
|
return file_audit_v1_routable_event_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
func (x *ObjectIdentifier) GetIdentifier() string {
|
|
if x != nil {
|
|
return x.Identifier
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ObjectIdentifier) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type EncryptedData struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Encrypted serialized protobuf content (the actual audit event)
|
|
//
|
|
// Required: true
|
|
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
|
|
// Name of the protobuf type
|
|
//
|
|
// Required: true
|
|
ProtobufType string `protobuf:"bytes,2,opt,name=protobuf_type,json=protobufType,proto3" json:"protobuf_type,omitempty"`
|
|
// The password taken to derive the encryption key from
|
|
//
|
|
// Required: true
|
|
EncryptedPassword string `protobuf:"bytes,3,opt,name=encrypted_password,json=encryptedPassword,proto3" json:"encrypted_password,omitempty"`
|
|
// Version of the encrypted key
|
|
//
|
|
// Required: true
|
|
KeyVersion int32 `protobuf:"varint,4,opt,name=key_version,json=keyVersion,proto3" json:"key_version,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *EncryptedData) Reset() {
|
|
*x = EncryptedData{}
|
|
mi := &file_audit_v1_routable_event_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *EncryptedData) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*EncryptedData) ProtoMessage() {}
|
|
|
|
func (x *EncryptedData) ProtoReflect() protoreflect.Message {
|
|
mi := &file_audit_v1_routable_event_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 EncryptedData.ProtoReflect.Descriptor instead.
|
|
func (*EncryptedData) Descriptor() ([]byte, []int) {
|
|
return file_audit_v1_routable_event_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *EncryptedData) GetData() []byte {
|
|
if x != nil {
|
|
return x.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *EncryptedData) GetProtobufType() string {
|
|
if x != nil {
|
|
return x.ProtobufType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *EncryptedData) GetEncryptedPassword() string {
|
|
if x != nil {
|
|
return x.EncryptedPassword
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *EncryptedData) GetKeyVersion() int32 {
|
|
if x != nil {
|
|
return x.KeyVersion
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type UnencryptedData struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Unencrypted serialized protobuf content (the actual audit event)
|
|
//
|
|
// Required: true
|
|
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
|
|
// Name of the protobuf type
|
|
//
|
|
// Required: true
|
|
ProtobufType string `protobuf:"bytes,2,opt,name=protobuf_type,json=protobufType,proto3" json:"protobuf_type,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *UnencryptedData) Reset() {
|
|
*x = UnencryptedData{}
|
|
mi := &file_audit_v1_routable_event_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *UnencryptedData) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*UnencryptedData) ProtoMessage() {}
|
|
|
|
func (x *UnencryptedData) ProtoReflect() protoreflect.Message {
|
|
mi := &file_audit_v1_routable_event_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 UnencryptedData.ProtoReflect.Descriptor instead.
|
|
func (*UnencryptedData) Descriptor() ([]byte, []int) {
|
|
return file_audit_v1_routable_event_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
func (x *UnencryptedData) GetData() []byte {
|
|
if x != nil {
|
|
return x.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *UnencryptedData) GetProtobufType() string {
|
|
if x != nil {
|
|
return x.ProtobufType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type RoutableAuditEvent struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Functional event name with pattern
|
|
//
|
|
// Format: stackit.<product>.<version>.<type-chain>.<operation>
|
|
// Where:
|
|
//
|
|
// Product: The name of the service in lowercase
|
|
// Version: Optional API version
|
|
// Type-Chain: Chained path to object
|
|
// Operation: The name of the operation in lowercase
|
|
//
|
|
// Examples:
|
|
//
|
|
// "stackit.resource-manager.v1.organizations.create"
|
|
// "stackit.authorization.v1.projects.volumes.create"
|
|
// "stackit.authorization.v2alpha.projects.volumes.create"
|
|
// "stackit.authorization.v2.folders.move"
|
|
// "stackit.resource-manager.health"
|
|
//
|
|
// Required: true
|
|
OperationName string `protobuf:"bytes,1,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"`
|
|
// Visibility relevant for differentiating between internal and public events
|
|
//
|
|
// Required: true
|
|
Visibility Visibility `protobuf:"varint,2,opt,name=visibility,proto3,enum=audit.v1.Visibility" json:"visibility,omitempty"`
|
|
// Identifier the audit log event refers to.
|
|
//
|
|
// System events, will not be routed to the end-user.
|
|
//
|
|
// Required: true
|
|
ObjectIdentifier *ObjectIdentifier `protobuf:"bytes,3,opt,name=object_identifier,json=objectIdentifier,proto3" json:"object_identifier,omitempty"`
|
|
// The actual audit event is transferred in one of the attributes below
|
|
//
|
|
// Required: true
|
|
//
|
|
// Types that are valid to be assigned to Data:
|
|
//
|
|
// *RoutableAuditEvent_UnencryptedData
|
|
// *RoutableAuditEvent_EncryptedData
|
|
Data isRoutableAuditEvent_Data `protobuf_oneof:"data"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) Reset() {
|
|
*x = RoutableAuditEvent{}
|
|
mi := &file_audit_v1_routable_event_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RoutableAuditEvent) ProtoMessage() {}
|
|
|
|
func (x *RoutableAuditEvent) ProtoReflect() protoreflect.Message {
|
|
mi := &file_audit_v1_routable_event_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 RoutableAuditEvent.ProtoReflect.Descriptor instead.
|
|
func (*RoutableAuditEvent) Descriptor() ([]byte, []int) {
|
|
return file_audit_v1_routable_event_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetOperationName() string {
|
|
if x != nil {
|
|
return x.OperationName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetVisibility() Visibility {
|
|
if x != nil {
|
|
return x.Visibility
|
|
}
|
|
return Visibility_VISIBILITY_UNSPECIFIED
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetObjectIdentifier() *ObjectIdentifier {
|
|
if x != nil {
|
|
return x.ObjectIdentifier
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetData() isRoutableAuditEvent_Data {
|
|
if x != nil {
|
|
return x.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetUnencryptedData() *UnencryptedData {
|
|
if x != nil {
|
|
if x, ok := x.Data.(*RoutableAuditEvent_UnencryptedData); ok {
|
|
return x.UnencryptedData
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RoutableAuditEvent) GetEncryptedData() *EncryptedData {
|
|
if x != nil {
|
|
if x, ok := x.Data.(*RoutableAuditEvent_EncryptedData); ok {
|
|
return x.EncryptedData
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isRoutableAuditEvent_Data interface {
|
|
isRoutableAuditEvent_Data()
|
|
}
|
|
|
|
type RoutableAuditEvent_UnencryptedData struct {
|
|
UnencryptedData *UnencryptedData `protobuf:"bytes,4,opt,name=unencrypted_data,json=unencryptedData,proto3,oneof"`
|
|
}
|
|
|
|
type RoutableAuditEvent_EncryptedData struct {
|
|
EncryptedData *EncryptedData `protobuf:"bytes,5,opt,name=encrypted_data,json=encryptedData,proto3,oneof"`
|
|
}
|
|
|
|
func (*RoutableAuditEvent_UnencryptedData) isRoutableAuditEvent_Data() {}
|
|
|
|
func (*RoutableAuditEvent_EncryptedData) isRoutableAuditEvent_Data() {}
|
|
|
|
var File_audit_v1_routable_event_proto protoreflect.FileDescriptor
|
|
|
|
const file_audit_v1_routable_event_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\x1daudit/v1/routable_event.proto\x12\baudit.v1\x1a\x1bbuf/validate/validate.proto\"_\n" +
|
|
"\x10ObjectIdentifier\x12+\n" +
|
|
"\n" +
|
|
"identifier\x18\x01 \x01(\tB\v\xbaH\b\xc8\x01\x01r\x03\xb0\x01\x01R\n" +
|
|
"identifier\x12\x1e\n" +
|
|
"\x04type\x18\x02 \x01(\tB\n" +
|
|
"\xbaH\a\xc8\x01\x01r\x02\x10\x01R\x04type\"\xc5\x01\n" +
|
|
"\rEncryptedData\x12\x1e\n" +
|
|
"\x04data\x18\x01 \x01(\fB\n" +
|
|
"\xbaH\a\xc8\x01\x01z\x02\x10\x01R\x04data\x12/\n" +
|
|
"\rprotobuf_type\x18\x02 \x01(\tB\n" +
|
|
"\xbaH\a\xc8\x01\x01r\x02\x10\x01R\fprotobufType\x129\n" +
|
|
"\x12encrypted_password\x18\x03 \x01(\tB\n" +
|
|
"\xbaH\a\xc8\x01\x01r\x02\x10\x01R\x11encryptedPassword\x12(\n" +
|
|
"\vkey_version\x18\x04 \x01(\x05B\a\xbaH\x04\x1a\x02(\x01R\n" +
|
|
"keyVersion\"b\n" +
|
|
"\x0fUnencryptedData\x12\x1e\n" +
|
|
"\x04data\x18\x01 \x01(\fB\n" +
|
|
"\xbaH\a\xc8\x01\x01z\x02\x10\x01R\x04data\x12/\n" +
|
|
"\rprotobuf_type\x18\x02 \x01(\tB\n" +
|
|
"\xbaH\a\xc8\x01\x01r\x02\x10\x01R\fprotobufType\"\xb5\x03\n" +
|
|
"\x12RoutableAuditEvent\x12r\n" +
|
|
"\x0eoperation_name\x18\x01 \x01(\tBK\xbaHH\xc8\x01\x01rC2A^stackit\\.[a-z0-9-]+\\.(?:v[0-9]+\\.)?(?:[a-z0-9-.]+\\.)?[a-z0-9-]+$R\roperationName\x12A\n" +
|
|
"\n" +
|
|
"visibility\x18\x02 \x01(\x0e2\x14.audit.v1.VisibilityB\v\xbaH\b\xc8\x01\x01\x82\x01\x02\x10\x01R\n" +
|
|
"visibility\x12O\n" +
|
|
"\x11object_identifier\x18\x03 \x01(\v2\x1a.audit.v1.ObjectIdentifierB\x06\xbaH\x03\xc8\x01\x01R\x10objectIdentifier\x12F\n" +
|
|
"\x10unencrypted_data\x18\x04 \x01(\v2\x19.audit.v1.UnencryptedDataH\x00R\x0funencryptedData\x12@\n" +
|
|
"\x0eencrypted_data\x18\x05 \x01(\v2\x17.audit.v1.EncryptedDataH\x00R\rencryptedDataB\r\n" +
|
|
"\x04data\x12\x05\xbaH\x02\b\x01*W\n" +
|
|
"\n" +
|
|
"Visibility\x12\x1a\n" +
|
|
"\x16VISIBILITY_UNSPECIFIED\x10\x00\x12\x15\n" +
|
|
"\x11VISIBILITY_PUBLIC\x10\x01\x12\x16\n" +
|
|
"\x12VISIBILITY_PRIVATE\x10\x02B1\n" +
|
|
"\x1ccom.schwarz.stackit.audit.v1P\x01Z\x0f./audit;auditV1b\x06proto3"
|
|
|
|
var (
|
|
file_audit_v1_routable_event_proto_rawDescOnce sync.Once
|
|
file_audit_v1_routable_event_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_audit_v1_routable_event_proto_rawDescGZIP() []byte {
|
|
file_audit_v1_routable_event_proto_rawDescOnce.Do(func() {
|
|
file_audit_v1_routable_event_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_audit_v1_routable_event_proto_rawDesc), len(file_audit_v1_routable_event_proto_rawDesc)))
|
|
})
|
|
return file_audit_v1_routable_event_proto_rawDescData
|
|
}
|
|
|
|
var file_audit_v1_routable_event_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
|
|
var file_audit_v1_routable_event_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
|
|
var file_audit_v1_routable_event_proto_goTypes = []any{
|
|
(Visibility)(0), // 0: audit.v1.Visibility
|
|
(*ObjectIdentifier)(nil), // 1: audit.v1.ObjectIdentifier
|
|
(*EncryptedData)(nil), // 2: audit.v1.EncryptedData
|
|
(*UnencryptedData)(nil), // 3: audit.v1.UnencryptedData
|
|
(*RoutableAuditEvent)(nil), // 4: audit.v1.RoutableAuditEvent
|
|
}
|
|
var file_audit_v1_routable_event_proto_depIdxs = []int32{
|
|
0, // 0: audit.v1.RoutableAuditEvent.visibility:type_name -> audit.v1.Visibility
|
|
1, // 1: audit.v1.RoutableAuditEvent.object_identifier:type_name -> audit.v1.ObjectIdentifier
|
|
3, // 2: audit.v1.RoutableAuditEvent.unencrypted_data:type_name -> audit.v1.UnencryptedData
|
|
2, // 3: audit.v1.RoutableAuditEvent.encrypted_data:type_name -> audit.v1.EncryptedData
|
|
4, // [4:4] is the sub-list for method output_type
|
|
4, // [4:4] is the sub-list for method input_type
|
|
4, // [4:4] is the sub-list for extension type_name
|
|
4, // [4:4] is the sub-list for extension extendee
|
|
0, // [0:4] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_audit_v1_routable_event_proto_init() }
|
|
func file_audit_v1_routable_event_proto_init() {
|
|
if File_audit_v1_routable_event_proto != nil {
|
|
return
|
|
}
|
|
file_audit_v1_routable_event_proto_msgTypes[3].OneofWrappers = []any{
|
|
(*RoutableAuditEvent_UnencryptedData)(nil),
|
|
(*RoutableAuditEvent_EncryptedData)(nil),
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_audit_v1_routable_event_proto_rawDesc), len(file_audit_v1_routable_event_proto_rawDesc)),
|
|
NumEnums: 1,
|
|
NumMessages: 4,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_audit_v1_routable_event_proto_goTypes,
|
|
DependencyIndexes: file_audit_v1_routable_event_proto_depIdxs,
|
|
EnumInfos: file_audit_v1_routable_event_proto_enumTypes,
|
|
MessageInfos: file_audit_v1_routable_event_proto_msgTypes,
|
|
}.Build()
|
|
File_audit_v1_routable_event_proto = out.File
|
|
file_audit_v1_routable_event_proto_goTypes = nil
|
|
file_audit_v1_routable_event_proto_depIdxs = nil
|
|
}
|