text:
package sha

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type StorageScanner struct {
	NotificationConfigName string                  `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *StorageScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                `json:"-"`
	XXX_unrecognized       []byte                  `json:"-"`
	XXX_sizecache          int32                   `json:"-"`
}

func (m *StorageScanner) Reset()         { *m = StorageScanner{} }
func (m *StorageScanner) String() string { return proto.CompactTextString(m) }
func (*StorageScanner) ProtoMessage()    {}
func (*StorageScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{0}
}

func (m *StorageScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageScanner.Unmarshal(m, b)
}
func (m *StorageScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageScanner.Marshal(b, m, deterministic)
}
func (m *StorageScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageScanner.Merge(m, src)
}
func (m *StorageScanner) XXX_Size() int {
	return xxx_messageInfo_StorageScanner.Size(m)
}
func (m *StorageScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageScanner.DiscardUnknown(m)
}

var xxx_messageInfo_StorageScanner proto.InternalMessageInfo

func (m *StorageScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *StorageScanner) GetFinding() *StorageScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type StorageScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *StorageScanner_SecurityMarks) Reset()         { *m = StorageScanner_SecurityMarks{} }
func (m *StorageScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*StorageScanner_SecurityMarks) ProtoMessage()    {}
func (*StorageScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{0, 0}
}

func (m *StorageScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *StorageScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *StorageScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageScanner_SecurityMarks.Merge(m, src)
}
func (m *StorageScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_StorageScanner_SecurityMarks.Size(m)
}
func (m *StorageScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_StorageScanner_SecurityMarks proto.InternalMessageInfo

func (m *StorageScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type StorageScanner_SourceProperties struct {
	ProjectId            string   `protobuf:"bytes,1,opt,name=projectId,proto3" json:"projectId,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StorageScanner_SourceProperties) Reset()         { *m = StorageScanner_SourceProperties{} }
func (m *StorageScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*StorageScanner_SourceProperties) ProtoMessage()    {}
func (*StorageScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{0, 1}
}

func (m *StorageScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageScanner_SourceProperties.Unmarshal(m, b)
}
func (m *StorageScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *StorageScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageScanner_SourceProperties.Merge(m, src)
}
func (m *StorageScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_StorageScanner_SourceProperties.Size(m)
}
func (m *StorageScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_StorageScanner_SourceProperties proto.InternalMessageInfo

func (m *StorageScanner_SourceProperties) GetProjectId() string {
	if m != nil {
		return m.ProjectId
	}
	return ""
}

func (m *StorageScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type StorageScanner_Finding struct {
	SourceProperties     *StorageScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	ResourceName         string                           `protobuf:"bytes,2,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	Category             string                           `protobuf:"bytes,3,opt,name=category,proto3" json:"category,omitempty"`
	State                string                           `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *StorageScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                           `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                           `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *StorageScanner_Finding) Reset()         { *m = StorageScanner_Finding{} }
func (m *StorageScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*StorageScanner_Finding) ProtoMessage()    {}
func (*StorageScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{0, 2}
}

func (m *StorageScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageScanner_Finding.Unmarshal(m, b)
}
func (m *StorageScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageScanner_Finding.Marshal(b, m, deterministic)
}
func (m *StorageScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageScanner_Finding.Merge(m, src)
}
func (m *StorageScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_StorageScanner_Finding.Size(m)
}
func (m *StorageScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_StorageScanner_Finding proto.InternalMessageInfo

func (m *StorageScanner_Finding) GetSourceProperties() *StorageScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *StorageScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

func (m *StorageScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

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

func (m *StorageScanner_Finding) GetSecurityMarks() *StorageScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *StorageScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *StorageScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type FirewallScanner struct {
	NotificationConfigName string                   `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *FirewallScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                 `json:"-"`
	XXX_unrecognized       []byte                   `json:"-"`
	XXX_sizecache          int32                    `json:"-"`
}

func (m *FirewallScanner) Reset()         { *m = FirewallScanner{} }
func (m *FirewallScanner) String() string { return proto.CompactTextString(m) }
func (*FirewallScanner) ProtoMessage()    {}
func (*FirewallScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{1}
}

func (m *FirewallScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirewallScanner.Unmarshal(m, b)
}
func (m *FirewallScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirewallScanner.Marshal(b, m, deterministic)
}
func (m *FirewallScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirewallScanner.Merge(m, src)
}
func (m *FirewallScanner) XXX_Size() int {
	return xxx_messageInfo_FirewallScanner.Size(m)
}
func (m *FirewallScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_FirewallScanner.DiscardUnknown(m)
}

var xxx_messageInfo_FirewallScanner proto.InternalMessageInfo

func (m *FirewallScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *FirewallScanner) GetFinding() *FirewallScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type FirewallScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *FirewallScanner_SecurityMarks) Reset()         { *m = FirewallScanner_SecurityMarks{} }
func (m *FirewallScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*FirewallScanner_SecurityMarks) ProtoMessage()    {}
func (*FirewallScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{1, 0}
}

func (m *FirewallScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirewallScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *FirewallScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirewallScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *FirewallScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirewallScanner_SecurityMarks.Merge(m, src)
}
func (m *FirewallScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_FirewallScanner_SecurityMarks.Size(m)
}
func (m *FirewallScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_FirewallScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_FirewallScanner_SecurityMarks proto.InternalMessageInfo

func (m *FirewallScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type FirewallScanner_SourceProperties struct {
	ProjectId            string   `protobuf:"bytes,1,opt,name=projectId,proto3" json:"projectId,omitempty"`
	Allowed              string   `protobuf:"bytes,2,opt,name=allowed,proto3" json:"allowed,omitempty"`
	AllowedIpRange       string   `protobuf:"bytes,3,opt,name=allowedIpRange,proto3" json:"allowedIpRange,omitempty"`
	ActivationTrigger    string   `protobuf:"bytes,4,opt,name=activationTrigger,proto3" json:"activationTrigger,omitempty"`
	SourceRange          string   `protobuf:"bytes,5,opt,name=sourceRange,proto3" json:"sourceRange,omitempty"`
	ScannerName          string   `protobuf:"bytes,6,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FirewallScanner_SourceProperties) Reset()         { *m = FirewallScanner_SourceProperties{} }
func (m *FirewallScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*FirewallScanner_SourceProperties) ProtoMessage()    {}
func (*FirewallScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{1, 1}
}

func (m *FirewallScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirewallScanner_SourceProperties.Unmarshal(m, b)
}
func (m *FirewallScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirewallScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *FirewallScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirewallScanner_SourceProperties.Merge(m, src)
}
func (m *FirewallScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_FirewallScanner_SourceProperties.Size(m)
}
func (m *FirewallScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_FirewallScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_FirewallScanner_SourceProperties proto.InternalMessageInfo

func (m *FirewallScanner_SourceProperties) GetProjectId() string {
	if m != nil {
		return m.ProjectId
	}
	return ""
}

func (m *FirewallScanner_SourceProperties) GetAllowed() string {
	if m != nil {
		return m.Allowed
	}
	return ""
}

func (m *FirewallScanner_SourceProperties) GetAllowedIpRange() string {
	if m != nil {
		return m.AllowedIpRange
	}
	return ""
}

func (m *FirewallScanner_SourceProperties) GetActivationTrigger() string {
	if m != nil {
		return m.ActivationTrigger
	}
	return ""
}

func (m *FirewallScanner_SourceProperties) GetSourceRange() string {
	if m != nil {
		return m.SourceRange
	}
	return ""
}

func (m *FirewallScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type FirewallScanner_Finding struct {
	SourceProperties     *FirewallScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                            `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                            `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                            `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *FirewallScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                            `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                            `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *FirewallScanner_Finding) Reset()         { *m = FirewallScanner_Finding{} }
func (m *FirewallScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*FirewallScanner_Finding) ProtoMessage()    {}
func (*FirewallScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{1, 2}
}

func (m *FirewallScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirewallScanner_Finding.Unmarshal(m, b)
}
func (m *FirewallScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirewallScanner_Finding.Marshal(b, m, deterministic)
}
func (m *FirewallScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirewallScanner_Finding.Merge(m, src)
}
func (m *FirewallScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_FirewallScanner_Finding.Size(m)
}
func (m *FirewallScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_FirewallScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_FirewallScanner_Finding proto.InternalMessageInfo

func (m *FirewallScanner_Finding) GetSourceProperties() *FirewallScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *FirewallScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *FirewallScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *FirewallScanner_Finding) GetSecurityMarks() *FirewallScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *FirewallScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *FirewallScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type ComputeInstanceScanner struct {
	NotificationConfigName string                          `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *ComputeInstanceScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                        `json:"-"`
	XXX_unrecognized       []byte                          `json:"-"`
	XXX_sizecache          int32                           `json:"-"`
}

func (m *ComputeInstanceScanner) Reset()         { *m = ComputeInstanceScanner{} }
func (m *ComputeInstanceScanner) String() string { return proto.CompactTextString(m) }
func (*ComputeInstanceScanner) ProtoMessage()    {}
func (*ComputeInstanceScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{2}
}

func (m *ComputeInstanceScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ComputeInstanceScanner.Unmarshal(m, b)
}
func (m *ComputeInstanceScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ComputeInstanceScanner.Marshal(b, m, deterministic)
}
func (m *ComputeInstanceScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeInstanceScanner.Merge(m, src)
}
func (m *ComputeInstanceScanner) XXX_Size() int {
	return xxx_messageInfo_ComputeInstanceScanner.Size(m)
}
func (m *ComputeInstanceScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeInstanceScanner.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeInstanceScanner proto.InternalMessageInfo

func (m *ComputeInstanceScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *ComputeInstanceScanner) GetFinding() *ComputeInstanceScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type ComputeInstanceScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ComputeInstanceScanner_SecurityMarks) Reset()         { *m = ComputeInstanceScanner_SecurityMarks{} }
func (m *ComputeInstanceScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*ComputeInstanceScanner_SecurityMarks) ProtoMessage()    {}
func (*ComputeInstanceScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{2, 0}
}

func (m *ComputeInstanceScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ComputeInstanceScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *ComputeInstanceScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ComputeInstanceScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *ComputeInstanceScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeInstanceScanner_SecurityMarks.Merge(m, src)
}
func (m *ComputeInstanceScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_ComputeInstanceScanner_SecurityMarks.Size(m)
}
func (m *ComputeInstanceScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeInstanceScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeInstanceScanner_SecurityMarks proto.InternalMessageInfo

func (m *ComputeInstanceScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type ComputeInstanceScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ComputeInstanceScanner_SourceProperties) Reset() {
	*m = ComputeInstanceScanner_SourceProperties{}
}
func (m *ComputeInstanceScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*ComputeInstanceScanner_SourceProperties) ProtoMessage()    {}
func (*ComputeInstanceScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{2, 1}
}

func (m *ComputeInstanceScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ComputeInstanceScanner_SourceProperties.Unmarshal(m, b)
}
func (m *ComputeInstanceScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ComputeInstanceScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *ComputeInstanceScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeInstanceScanner_SourceProperties.Merge(m, src)
}
func (m *ComputeInstanceScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_ComputeInstanceScanner_SourceProperties.Size(m)
}
func (m *ComputeInstanceScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeInstanceScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeInstanceScanner_SourceProperties proto.InternalMessageInfo

func (m *ComputeInstanceScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *ComputeInstanceScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type ComputeInstanceScanner_Finding struct {
	SourceProperties     *ComputeInstanceScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                                   `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                                   `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                                   `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *ComputeInstanceScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                                   `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                                   `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
	XXX_unrecognized     []byte                                   `json:"-"`
	XXX_sizecache        int32                                    `json:"-"`
}

func (m *ComputeInstanceScanner_Finding) Reset()         { *m = ComputeInstanceScanner_Finding{} }
func (m *ComputeInstanceScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*ComputeInstanceScanner_Finding) ProtoMessage()    {}
func (*ComputeInstanceScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{2, 2}
}

func (m *ComputeInstanceScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ComputeInstanceScanner_Finding.Unmarshal(m, b)
}
func (m *ComputeInstanceScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ComputeInstanceScanner_Finding.Marshal(b, m, deterministic)
}
func (m *ComputeInstanceScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeInstanceScanner_Finding.Merge(m, src)
}
func (m *ComputeInstanceScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_ComputeInstanceScanner_Finding.Size(m)
}
func (m *ComputeInstanceScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeInstanceScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeInstanceScanner_Finding proto.InternalMessageInfo

func (m *ComputeInstanceScanner_Finding) GetSourceProperties() *ComputeInstanceScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *ComputeInstanceScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *ComputeInstanceScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *ComputeInstanceScanner_Finding) GetSecurityMarks() *ComputeInstanceScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *ComputeInstanceScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *ComputeInstanceScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type DatasetScanner struct {
	NotificationConfigName string                  `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *DatasetScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                `json:"-"`
	XXX_unrecognized       []byte                  `json:"-"`
	XXX_sizecache          int32                   `json:"-"`
}

func (m *DatasetScanner) Reset()         { *m = DatasetScanner{} }
func (m *DatasetScanner) String() string { return proto.CompactTextString(m) }
func (*DatasetScanner) ProtoMessage()    {}
func (*DatasetScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{3}
}

func (m *DatasetScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DatasetScanner.Unmarshal(m, b)
}
func (m *DatasetScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DatasetScanner.Marshal(b, m, deterministic)
}
func (m *DatasetScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatasetScanner.Merge(m, src)
}
func (m *DatasetScanner) XXX_Size() int {
	return xxx_messageInfo_DatasetScanner.Size(m)
}
func (m *DatasetScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_DatasetScanner.DiscardUnknown(m)
}

var xxx_messageInfo_DatasetScanner proto.InternalMessageInfo

func (m *DatasetScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *DatasetScanner) GetFinding() *DatasetScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type DatasetScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DatasetScanner_SecurityMarks) Reset()         { *m = DatasetScanner_SecurityMarks{} }
func (m *DatasetScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*DatasetScanner_SecurityMarks) ProtoMessage()    {}
func (*DatasetScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{3, 0}
}

func (m *DatasetScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DatasetScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *DatasetScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DatasetScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *DatasetScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatasetScanner_SecurityMarks.Merge(m, src)
}
func (m *DatasetScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_DatasetScanner_SecurityMarks.Size(m)
}
func (m *DatasetScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_DatasetScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_DatasetScanner_SecurityMarks proto.InternalMessageInfo

func (m *DatasetScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type DatasetScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DatasetScanner_SourceProperties) Reset()         { *m = DatasetScanner_SourceProperties{} }
func (m *DatasetScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*DatasetScanner_SourceProperties) ProtoMessage()    {}
func (*DatasetScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{3, 1}
}

func (m *DatasetScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DatasetScanner_SourceProperties.Unmarshal(m, b)
}
func (m *DatasetScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DatasetScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *DatasetScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatasetScanner_SourceProperties.Merge(m, src)
}
func (m *DatasetScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_DatasetScanner_SourceProperties.Size(m)
}
func (m *DatasetScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_DatasetScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_DatasetScanner_SourceProperties proto.InternalMessageInfo

func (m *DatasetScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *DatasetScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type DatasetScanner_Finding struct {
	SourceProperties     *DatasetScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                           `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                           `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                           `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *DatasetScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                           `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                           `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *DatasetScanner_Finding) Reset()         { *m = DatasetScanner_Finding{} }
func (m *DatasetScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*DatasetScanner_Finding) ProtoMessage()    {}
func (*DatasetScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{3, 2}
}

func (m *DatasetScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DatasetScanner_Finding.Unmarshal(m, b)
}
func (m *DatasetScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DatasetScanner_Finding.Marshal(b, m, deterministic)
}
func (m *DatasetScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatasetScanner_Finding.Merge(m, src)
}
func (m *DatasetScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_DatasetScanner_Finding.Size(m)
}
func (m *DatasetScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_DatasetScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_DatasetScanner_Finding proto.InternalMessageInfo

func (m *DatasetScanner_Finding) GetSourceProperties() *DatasetScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *DatasetScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *DatasetScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *DatasetScanner_Finding) GetSecurityMarks() *DatasetScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *DatasetScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *DatasetScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type IamScanner struct {
	NotificationConfigName string              `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *IamScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}            `json:"-"`
	XXX_unrecognized       []byte              `json:"-"`
	XXX_sizecache          int32               `json:"-"`
}

func (m *IamScanner) Reset()         { *m = IamScanner{} }
func (m *IamScanner) String() string { return proto.CompactTextString(m) }
func (*IamScanner) ProtoMessage()    {}
func (*IamScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{4}
}

func (m *IamScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IamScanner.Unmarshal(m, b)
}
func (m *IamScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IamScanner.Marshal(b, m, deterministic)
}
func (m *IamScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IamScanner.Merge(m, src)
}
func (m *IamScanner) XXX_Size() int {
	return xxx_messageInfo_IamScanner.Size(m)
}
func (m *IamScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_IamScanner.DiscardUnknown(m)
}

var xxx_messageInfo_IamScanner proto.InternalMessageInfo

func (m *IamScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *IamScanner) GetFinding() *IamScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type IamScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *IamScanner_SecurityMarks) Reset()         { *m = IamScanner_SecurityMarks{} }
func (m *IamScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*IamScanner_SecurityMarks) ProtoMessage()    {}
func (*IamScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{4, 0}
}

func (m *IamScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IamScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *IamScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IamScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *IamScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IamScanner_SecurityMarks.Merge(m, src)
}
func (m *IamScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_IamScanner_SecurityMarks.Size(m)
}
func (m *IamScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_IamScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_IamScanner_SecurityMarks proto.InternalMessageInfo

func (m *IamScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type IamScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	OffendingIamRoles    string   `protobuf:"bytes,2,opt,name=offendingIamRoles,proto3" json:"offendingIamRoles,omitempty"`
	ScannerName          string   `protobuf:"bytes,3,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IamScanner_SourceProperties) Reset()         { *m = IamScanner_SourceProperties{} }
func (m *IamScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*IamScanner_SourceProperties) ProtoMessage()    {}
func (*IamScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{4, 1}
}

func (m *IamScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IamScanner_SourceProperties.Unmarshal(m, b)
}
func (m *IamScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IamScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *IamScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IamScanner_SourceProperties.Merge(m, src)
}
func (m *IamScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_IamScanner_SourceProperties.Size(m)
}
func (m *IamScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_IamScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_IamScanner_SourceProperties proto.InternalMessageInfo

func (m *IamScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *IamScanner_SourceProperties) GetOffendingIamRoles() string {
	if m != nil {
		return m.OffendingIamRoles
	}
	return ""
}

func (m *IamScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type IamScanner_Finding struct {
	SourceProperties     *IamScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                       `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	Parent               string                       `protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"`
	State                string                       `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	ResourceName         string                       `protobuf:"bytes,5,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	SecurityMarks        *IamScanner_SecurityMarks    `protobuf:"bytes,6,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                       `protobuf:"bytes,7,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                       `protobuf:"bytes,8,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *IamScanner_Finding) Reset()         { *m = IamScanner_Finding{} }
func (m *IamScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*IamScanner_Finding) ProtoMessage()    {}
func (*IamScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{4, 2}
}

func (m *IamScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IamScanner_Finding.Unmarshal(m, b)
}
func (m *IamScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IamScanner_Finding.Marshal(b, m, deterministic)
}
func (m *IamScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IamScanner_Finding.Merge(m, src)
}
func (m *IamScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_IamScanner_Finding.Size(m)
}
func (m *IamScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_IamScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_IamScanner_Finding proto.InternalMessageInfo

func (m *IamScanner_Finding) GetSourceProperties() *IamScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *IamScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *IamScanner_Finding) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

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

func (m *IamScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

func (m *IamScanner_Finding) GetSecurityMarks() *IamScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *IamScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *IamScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type SqlScanner struct {
	NotificationConfigName string              `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *SqlScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}            `json:"-"`
	XXX_unrecognized       []byte              `json:"-"`
	XXX_sizecache          int32               `json:"-"`
}

func (m *SqlScanner) Reset()         { *m = SqlScanner{} }
func (m *SqlScanner) String() string { return proto.CompactTextString(m) }
func (*SqlScanner) ProtoMessage()    {}
func (*SqlScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{5}
}

func (m *SqlScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SqlScanner.Unmarshal(m, b)
}
func (m *SqlScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SqlScanner.Marshal(b, m, deterministic)
}
func (m *SqlScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SqlScanner.Merge(m, src)
}
func (m *SqlScanner) XXX_Size() int {
	return xxx_messageInfo_SqlScanner.Size(m)
}
func (m *SqlScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_SqlScanner.DiscardUnknown(m)
}

var xxx_messageInfo_SqlScanner proto.InternalMessageInfo

func (m *SqlScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *SqlScanner) GetFinding() *SqlScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type SqlScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SqlScanner_SecurityMarks) Reset()         { *m = SqlScanner_SecurityMarks{} }
func (m *SqlScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*SqlScanner_SecurityMarks) ProtoMessage()    {}
func (*SqlScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{5, 0}
}

func (m *SqlScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SqlScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *SqlScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SqlScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *SqlScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SqlScanner_SecurityMarks.Merge(m, src)
}
func (m *SqlScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_SqlScanner_SecurityMarks.Size(m)
}
func (m *SqlScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_SqlScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_SqlScanner_SecurityMarks proto.InternalMessageInfo

func (m *SqlScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type SqlScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SqlScanner_SourceProperties) Reset()         { *m = SqlScanner_SourceProperties{} }
func (m *SqlScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*SqlScanner_SourceProperties) ProtoMessage()    {}
func (*SqlScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{5, 1}
}

func (m *SqlScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SqlScanner_SourceProperties.Unmarshal(m, b)
}
func (m *SqlScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SqlScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *SqlScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SqlScanner_SourceProperties.Merge(m, src)
}
func (m *SqlScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_SqlScanner_SourceProperties.Size(m)
}
func (m *SqlScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_SqlScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_SqlScanner_SourceProperties proto.InternalMessageInfo

func (m *SqlScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *SqlScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type SqlScanner_Finding struct {
	SourceProperties     *SqlScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                       `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                       `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                       `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *SqlScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                       `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                       `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *SqlScanner_Finding) Reset()         { *m = SqlScanner_Finding{} }
func (m *SqlScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*SqlScanner_Finding) ProtoMessage()    {}
func (*SqlScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{5, 2}
}

func (m *SqlScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SqlScanner_Finding.Unmarshal(m, b)
}
func (m *SqlScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SqlScanner_Finding.Marshal(b, m, deterministic)
}
func (m *SqlScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SqlScanner_Finding.Merge(m, src)
}
func (m *SqlScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_SqlScanner_Finding.Size(m)
}
func (m *SqlScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_SqlScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_SqlScanner_Finding proto.InternalMessageInfo

func (m *SqlScanner_Finding) GetSourceProperties() *SqlScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *SqlScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *SqlScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *SqlScanner_Finding) GetSecurityMarks() *SqlScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *SqlScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *SqlScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type ContainerScanner struct {
	NotificationConfigName string                    `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *ContainerScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                  `json:"-"`
	XXX_unrecognized       []byte                    `json:"-"`
	XXX_sizecache          int32                     `json:"-"`
}

func (m *ContainerScanner) Reset()         { *m = ContainerScanner{} }
func (m *ContainerScanner) String() string { return proto.CompactTextString(m) }
func (*ContainerScanner) ProtoMessage()    {}
func (*ContainerScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{6}
}

func (m *ContainerScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainerScanner.Unmarshal(m, b)
}
func (m *ContainerScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainerScanner.Marshal(b, m, deterministic)
}
func (m *ContainerScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerScanner.Merge(m, src)
}
func (m *ContainerScanner) XXX_Size() int {
	return xxx_messageInfo_ContainerScanner.Size(m)
}
func (m *ContainerScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerScanner.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerScanner proto.InternalMessageInfo

func (m *ContainerScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *ContainerScanner) GetFinding() *ContainerScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type ContainerScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ContainerScanner_SecurityMarks) Reset()         { *m = ContainerScanner_SecurityMarks{} }
func (m *ContainerScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*ContainerScanner_SecurityMarks) ProtoMessage()    {}
func (*ContainerScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{6, 0}
}

func (m *ContainerScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainerScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *ContainerScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainerScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *ContainerScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerScanner_SecurityMarks.Merge(m, src)
}
func (m *ContainerScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_ContainerScanner_SecurityMarks.Size(m)
}
func (m *ContainerScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerScanner_SecurityMarks proto.InternalMessageInfo

func (m *ContainerScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type ContainerScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContainerScanner_SourceProperties) Reset()         { *m = ContainerScanner_SourceProperties{} }
func (m *ContainerScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*ContainerScanner_SourceProperties) ProtoMessage()    {}
func (*ContainerScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{6, 1}
}

func (m *ContainerScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainerScanner_SourceProperties.Unmarshal(m, b)
}
func (m *ContainerScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainerScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *ContainerScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerScanner_SourceProperties.Merge(m, src)
}
func (m *ContainerScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_ContainerScanner_SourceProperties.Size(m)
}
func (m *ContainerScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerScanner_SourceProperties proto.InternalMessageInfo

func (m *ContainerScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *ContainerScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type ContainerScanner_Finding struct {
	SourceProperties     *ContainerScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                             `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                             `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                             `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *ContainerScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                             `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                             `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *ContainerScanner_Finding) Reset()         { *m = ContainerScanner_Finding{} }
func (m *ContainerScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*ContainerScanner_Finding) ProtoMessage()    {}
func (*ContainerScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{6, 2}
}

func (m *ContainerScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainerScanner_Finding.Unmarshal(m, b)
}
func (m *ContainerScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainerScanner_Finding.Marshal(b, m, deterministic)
}
func (m *ContainerScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerScanner_Finding.Merge(m, src)
}
func (m *ContainerScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_ContainerScanner_Finding.Size(m)
}
func (m *ContainerScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerScanner_Finding proto.InternalMessageInfo

func (m *ContainerScanner_Finding) GetSourceProperties() *ContainerScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *ContainerScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *ContainerScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *ContainerScanner_Finding) GetSecurityMarks() *ContainerScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *ContainerScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *ContainerScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type LoggingScanner struct {
	NotificationConfigName string                  `protobuf:"bytes,1,opt,name=notificationConfigName,proto3" json:"notificationConfigName,omitempty"`
	Finding                *LoggingScanner_Finding `protobuf:"bytes,2,opt,name=finding,proto3" json:"finding,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                `json:"-"`
	XXX_unrecognized       []byte                  `json:"-"`
	XXX_sizecache          int32                   `json:"-"`
}

func (m *LoggingScanner) Reset()         { *m = LoggingScanner{} }
func (m *LoggingScanner) String() string { return proto.CompactTextString(m) }
func (*LoggingScanner) ProtoMessage()    {}
func (*LoggingScanner) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{7}
}

func (m *LoggingScanner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoggingScanner.Unmarshal(m, b)
}
func (m *LoggingScanner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoggingScanner.Marshal(b, m, deterministic)
}
func (m *LoggingScanner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingScanner.Merge(m, src)
}
func (m *LoggingScanner) XXX_Size() int {
	return xxx_messageInfo_LoggingScanner.Size(m)
}
func (m *LoggingScanner) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingScanner.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingScanner proto.InternalMessageInfo

func (m *LoggingScanner) GetNotificationConfigName() string {
	if m != nil {
		return m.NotificationConfigName
	}
	return ""
}

func (m *LoggingScanner) GetFinding() *LoggingScanner_Finding {
	if m != nil {
		return m.Finding
	}
	return nil
}

type LoggingScanner_SecurityMarks struct {
	Marks                map[string]string `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *LoggingScanner_SecurityMarks) Reset()         { *m = LoggingScanner_SecurityMarks{} }
func (m *LoggingScanner_SecurityMarks) String() string { return proto.CompactTextString(m) }
func (*LoggingScanner_SecurityMarks) ProtoMessage()    {}
func (*LoggingScanner_SecurityMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{7, 0}
}

func (m *LoggingScanner_SecurityMarks) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoggingScanner_SecurityMarks.Unmarshal(m, b)
}
func (m *LoggingScanner_SecurityMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoggingScanner_SecurityMarks.Marshal(b, m, deterministic)
}
func (m *LoggingScanner_SecurityMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingScanner_SecurityMarks.Merge(m, src)
}
func (m *LoggingScanner_SecurityMarks) XXX_Size() int {
	return xxx_messageInfo_LoggingScanner_SecurityMarks.Size(m)
}
func (m *LoggingScanner_SecurityMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingScanner_SecurityMarks.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingScanner_SecurityMarks proto.InternalMessageInfo

func (m *LoggingScanner_SecurityMarks) GetMarks() map[string]string {
	if m != nil {
		return m.Marks
	}
	return nil
}

type LoggingScanner_SourceProperties struct {
	ProjectID            string   `protobuf:"bytes,1,opt,name=projectID,proto3" json:"projectID,omitempty"`
	ScannerName          string   `protobuf:"bytes,2,opt,name=ScannerName,proto3" json:"ScannerName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LoggingScanner_SourceProperties) Reset()         { *m = LoggingScanner_SourceProperties{} }
func (m *LoggingScanner_SourceProperties) String() string { return proto.CompactTextString(m) }
func (*LoggingScanner_SourceProperties) ProtoMessage()    {}
func (*LoggingScanner_SourceProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{7, 1}
}

func (m *LoggingScanner_SourceProperties) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoggingScanner_SourceProperties.Unmarshal(m, b)
}
func (m *LoggingScanner_SourceProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoggingScanner_SourceProperties.Marshal(b, m, deterministic)
}
func (m *LoggingScanner_SourceProperties) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingScanner_SourceProperties.Merge(m, src)
}
func (m *LoggingScanner_SourceProperties) XXX_Size() int {
	return xxx_messageInfo_LoggingScanner_SourceProperties.Size(m)
}
func (m *LoggingScanner_SourceProperties) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingScanner_SourceProperties.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingScanner_SourceProperties proto.InternalMessageInfo

func (m *LoggingScanner_SourceProperties) GetProjectID() string {
	if m != nil {
		return m.ProjectID
	}
	return ""
}

func (m *LoggingScanner_SourceProperties) GetScannerName() string {
	if m != nil {
		return m.ScannerName
	}
	return ""
}

type LoggingScanner_Finding struct {
	SourceProperties     *LoggingScanner_SourceProperties `protobuf:"bytes,1,opt,name=sourceProperties,proto3" json:"sourceProperties,omitempty"`
	Category             string                           `protobuf:"bytes,2,opt,name=category,proto3" json:"category,omitempty"`
	ResourceName         string                           `protobuf:"bytes,3,opt,name=resourceName,proto3" json:"resourceName,omitempty"`
	State                string                           `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	SecurityMarks        *LoggingScanner_SecurityMarks    `protobuf:"bytes,5,opt,name=securityMarks,proto3" json:"securityMarks,omitempty"`
	EventTime            string                           `protobuf:"bytes,6,opt,name=eventTime,proto3" json:"eventTime,omitempty"`
	Name                 string                           `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *LoggingScanner_Finding) Reset()         { *m = LoggingScanner_Finding{} }
func (m *LoggingScanner_Finding) String() string { return proto.CompactTextString(m) }
func (*LoggingScanner_Finding) ProtoMessage()    {}
func (*LoggingScanner_Finding) Descriptor() ([]byte, []int) {
	return fileDescriptor_42ce1b275ac7c5c9, []int{7, 2}
}

func (m *LoggingScanner_Finding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoggingScanner_Finding.Unmarshal(m, b)
}
func (m *LoggingScanner_Finding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoggingScanner_Finding.Marshal(b, m, deterministic)
}
func (m *LoggingScanner_Finding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingScanner_Finding.Merge(m, src)
}
func (m *LoggingScanner_Finding) XXX_Size() int {
	return xxx_messageInfo_LoggingScanner_Finding.Size(m)
}
func (m *LoggingScanner_Finding) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingScanner_Finding.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingScanner_Finding proto.InternalMessageInfo

func (m *LoggingScanner_Finding) GetSourceProperties() *LoggingScanner_SourceProperties {
	if m != nil {
		return m.SourceProperties
	}
	return nil
}

func (m *LoggingScanner_Finding) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *LoggingScanner_Finding) GetResourceName() string {
	if m != nil {
		return m.ResourceName
	}
	return ""
}

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

func (m *LoggingScanner_Finding) GetSecurityMarks() *LoggingScanner_SecurityMarks {
	if m != nil {
		return m.SecurityMarks
	}
	return nil
}

func (m *LoggingScanner_Finding) GetEventTime() string {
	if m != nil {
		return m.EventTime
	}
	return ""
}

func (m *LoggingScanner_Finding) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func init() {
	proto.RegisterType((*StorageScanner)(nil), "StorageScanner")
	proto.RegisterType((*StorageScanner_SecurityMarks)(nil), "StorageScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "StorageScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*StorageScanner_SourceProperties)(nil), "StorageScanner.SourceProperties")
	proto.RegisterType((*StorageScanner_Finding)(nil), "StorageScanner.Finding")
	proto.RegisterType((*FirewallScanner)(nil), "FirewallScanner")
	proto.RegisterType((*FirewallScanner_SecurityMarks)(nil), "FirewallScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "FirewallScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*FirewallScanner_SourceProperties)(nil), "FirewallScanner.SourceProperties")
	proto.RegisterType((*FirewallScanner_Finding)(nil), "FirewallScanner.Finding")
	proto.RegisterType((*ComputeInstanceScanner)(nil), "ComputeInstanceScanner")
	proto.RegisterType((*ComputeInstanceScanner_SecurityMarks)(nil), "ComputeInstanceScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "ComputeInstanceScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*ComputeInstanceScanner_SourceProperties)(nil), "ComputeInstanceScanner.SourceProperties")
	proto.RegisterType((*ComputeInstanceScanner_Finding)(nil), "ComputeInstanceScanner.Finding")
	proto.RegisterType((*DatasetScanner)(nil), "DatasetScanner")
	proto.RegisterType((*DatasetScanner_SecurityMarks)(nil), "DatasetScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "DatasetScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*DatasetScanner_SourceProperties)(nil), "DatasetScanner.SourceProperties")
	proto.RegisterType((*DatasetScanner_Finding)(nil), "DatasetScanner.Finding")
	proto.RegisterType((*IamScanner)(nil), "IamScanner")
	proto.RegisterType((*IamScanner_SecurityMarks)(nil), "IamScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "IamScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*IamScanner_SourceProperties)(nil), "IamScanner.SourceProperties")
	proto.RegisterType((*IamScanner_Finding)(nil), "IamScanner.Finding")
	proto.RegisterType((*SqlScanner)(nil), "SqlScanner")
	proto.RegisterType((*SqlScanner_SecurityMarks)(nil), "SqlScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "SqlScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*SqlScanner_SourceProperties)(nil), "SqlScanner.SourceProperties")
	proto.RegisterType((*SqlScanner_Finding)(nil), "SqlScanner.Finding")
	proto.RegisterType((*ContainerScanner)(nil), "ContainerScanner")
	proto.RegisterType((*ContainerScanner_SecurityMarks)(nil), "ContainerScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "ContainerScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*ContainerScanner_SourceProperties)(nil), "ContainerScanner.SourceProperties")
	proto.RegisterType((*ContainerScanner_Finding)(nil), "ContainerScanner.Finding")
	proto.RegisterType((*LoggingScanner)(nil), "LoggingScanner")
	proto.RegisterType((*LoggingScanner_SecurityMarks)(nil), "LoggingScanner.SecurityMarks")
	proto.RegisterMapType((map[string]string)(nil), "LoggingScanner.SecurityMarks.MarksEntry")
	proto.RegisterType((*LoggingScanner_SourceProperties)(nil), "LoggingScanner.SourceProperties")
	proto.RegisterType((*LoggingScanner_Finding)(nil), "LoggingScanner.Finding")
}

func init() { proto.RegisterFile("sha/protos/sha.proto", fileDescriptor_42ce1b275ac7c5c9) }

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


text:
module.exports = function() {
	function foobar() {
		return foobar.__ks_rt(this, arguments);
	};
	foobar.__ks_0 = function(args) {
	};
	foobar.__ks_rt = function(that, args) {
		return foobar.__ks_0.call(that, Array.from(args));
	};
	foobar.__ks_0([null]);
};

redpajama_set_name: RedPajamaGithub


text:
namespace ash {
namespace ime {

bool ImePreSandboxHook(sandbox::policy::SandboxLinux::Options options);

}  // namespace ime
}  // namespace ash

#endif  // ASH_SERVICES_IME_IME_SANDBOX_HOOK_H_


text:
#region S# License

#endregion S# License
namespace StockSharp.Xaml
{
	using Ecng.Xaml;

	using StockSharp.Messages;

	/// <summary>
	/// The drop-down list to select the instrument type.
	/// </summary>
	public class SecurityTypeComboBox : EnumComboBox
	{
		private const SecurityTypes _nullType = (SecurityTypes)(-1);

		/// <summary>
		/// Initializes a new instance of the <see cref="SecurityTypeComboBox"/>.
		/// </summary>
		public SecurityTypeComboBox()
		{
			EnumType = typeof(SecurityTypes);

			NullItem = new EnumComboBoxHelper.EnumerationMember
			{
				Description = string.Empty,
				Value = _nullType,
			};

			this.GetItemsSource().Insert(0, NullItem);

			SelectedType = null;
		}

		/// <summary>
		/// The entry for <see cref="SecurityTypeComboBox.SelectedType"/> which equals to <see langword="null" />.
		/// </summary>
		public EnumComboBoxHelper.EnumerationMember NullItem { get; }

		/// <summary>
		/// The selected instrument type.
		/// </summary>
		public SecurityTypes? SelectedType
		{
			get
			{
				var type = this.GetSelectedValue<SecurityTypes>();
				return type == _nullType ? null : type;
			}
			set
			{
				this.SetSelectedValue<SecurityTypes>(value ?? _nullType);
			}
		}
	}
}