| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // source: google/privacy/dlp/v2/storage.proto |
| |
| package dlp // import "google.golang.org/genproto/googleapis/privacy/dlp/v2" |
| |
| import proto "github.com/golang/protobuf/proto" |
| import fmt "fmt" |
| import math "math" |
| import timestamp "github.com/golang/protobuf/ptypes/timestamp" |
| import _ "google.golang.org/genproto/googleapis/api/annotations" |
| |
| // 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.ProtoPackageIsVersion2 // please upgrade the proto package |
| |
| // Categorization of results based on how likely they are to represent a match, |
| // based on the number of elements they contain which imply a match. |
| type Likelihood int32 |
| |
| const ( |
| // Default value; same as POSSIBLE. |
| Likelihood_LIKELIHOOD_UNSPECIFIED Likelihood = 0 |
| // Few matching elements. |
| Likelihood_VERY_UNLIKELY Likelihood = 1 |
| Likelihood_UNLIKELY Likelihood = 2 |
| // Some matching elements. |
| Likelihood_POSSIBLE Likelihood = 3 |
| Likelihood_LIKELY Likelihood = 4 |
| // Many matching elements. |
| Likelihood_VERY_LIKELY Likelihood = 5 |
| ) |
| |
| var Likelihood_name = map[int32]string{ |
| 0: "LIKELIHOOD_UNSPECIFIED", |
| 1: "VERY_UNLIKELY", |
| 2: "UNLIKELY", |
| 3: "POSSIBLE", |
| 4: "LIKELY", |
| 5: "VERY_LIKELY", |
| } |
| var Likelihood_value = map[string]int32{ |
| "LIKELIHOOD_UNSPECIFIED": 0, |
| "VERY_UNLIKELY": 1, |
| "UNLIKELY": 2, |
| "POSSIBLE": 3, |
| "LIKELY": 4, |
| "VERY_LIKELY": 5, |
| } |
| |
| func (x Likelihood) String() string { |
| return proto.EnumName(Likelihood_name, int32(x)) |
| } |
| func (Likelihood) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{0} |
| } |
| |
| // Definitions of file type groups to scan. |
| type FileType int32 |
| |
| const ( |
| // Includes all files. |
| FileType_FILE_TYPE_UNSPECIFIED FileType = 0 |
| // Includes all file extensions not covered by text file types. |
| FileType_BINARY_FILE FileType = 1 |
| // Included file extensions: |
| // asc, brf, c, cc, cpp, csv, cxx, c++, cs, css, dart, eml, go, h, hh, hpp, |
| // hxx, h++, hs, html, htm, shtml, shtm, xhtml, lhs, ini, java, js, json, |
| // ocaml, md, mkd, markdown, m, ml, mli, pl, pm, php, phtml, pht, py, pyw, |
| // rb, rbw, rs, rc, scala, sh, sql, tex, txt, text, tsv, vcard, vcs, wml, |
| // xml, xsl, xsd, yml, yaml. |
| FileType_TEXT_FILE FileType = 2 |
| ) |
| |
| var FileType_name = map[int32]string{ |
| 0: "FILE_TYPE_UNSPECIFIED", |
| 1: "BINARY_FILE", |
| 2: "TEXT_FILE", |
| } |
| var FileType_value = map[string]int32{ |
| "FILE_TYPE_UNSPECIFIED": 0, |
| "BINARY_FILE": 1, |
| "TEXT_FILE": 2, |
| } |
| |
| func (x FileType) String() string { |
| return proto.EnumName(FileType_name, int32(x)) |
| } |
| func (FileType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{1} |
| } |
| |
| // How to sample bytes if not all bytes are scanned. Meaningful only when used |
| // in conjunction with bytes_limit_per_file. If not specified, scanning would |
| // start from the top. |
| type CloudStorageOptions_SampleMethod int32 |
| |
| const ( |
| CloudStorageOptions_SAMPLE_METHOD_UNSPECIFIED CloudStorageOptions_SampleMethod = 0 |
| // Scan from the top (default). |
| CloudStorageOptions_TOP CloudStorageOptions_SampleMethod = 1 |
| // For each file larger than bytes_limit_per_file, randomly pick the offset |
| // to start scanning. The scanned bytes are contiguous. |
| CloudStorageOptions_RANDOM_START CloudStorageOptions_SampleMethod = 2 |
| ) |
| |
| var CloudStorageOptions_SampleMethod_name = map[int32]string{ |
| 0: "SAMPLE_METHOD_UNSPECIFIED", |
| 1: "TOP", |
| 2: "RANDOM_START", |
| } |
| var CloudStorageOptions_SampleMethod_value = map[string]int32{ |
| "SAMPLE_METHOD_UNSPECIFIED": 0, |
| "TOP": 1, |
| "RANDOM_START": 2, |
| } |
| |
| func (x CloudStorageOptions_SampleMethod) String() string { |
| return proto.EnumName(CloudStorageOptions_SampleMethod_name, int32(x)) |
| } |
| func (CloudStorageOptions_SampleMethod) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{7, 0} |
| } |
| |
| // How to sample rows if not all rows are scanned. Meaningful only when used |
| // in conjunction with rows_limit. If not specified, scanning would start |
| // from the top. |
| type BigQueryOptions_SampleMethod int32 |
| |
| const ( |
| BigQueryOptions_SAMPLE_METHOD_UNSPECIFIED BigQueryOptions_SampleMethod = 0 |
| // Scan from the top (default). |
| BigQueryOptions_TOP BigQueryOptions_SampleMethod = 1 |
| // Randomly pick the row to start scanning. The scanned rows are contiguous. |
| BigQueryOptions_RANDOM_START BigQueryOptions_SampleMethod = 2 |
| ) |
| |
| var BigQueryOptions_SampleMethod_name = map[int32]string{ |
| 0: "SAMPLE_METHOD_UNSPECIFIED", |
| 1: "TOP", |
| 2: "RANDOM_START", |
| } |
| var BigQueryOptions_SampleMethod_value = map[string]int32{ |
| "SAMPLE_METHOD_UNSPECIFIED": 0, |
| "TOP": 1, |
| "RANDOM_START": 2, |
| } |
| |
| func (x BigQueryOptions_SampleMethod) String() string { |
| return proto.EnumName(BigQueryOptions_SampleMethod_name, int32(x)) |
| } |
| func (BigQueryOptions_SampleMethod) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{10, 0} |
| } |
| |
| // Type of information detected by the API. |
| type InfoType struct { |
| // Name of the information type. Either a name of your choosing when |
| // creating a CustomInfoType, or one of the names listed |
| // at https://cloud.google.com/dlp/docs/infotypes-reference when specifying |
| // a built-in type. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *InfoType) Reset() { *m = InfoType{} } |
| func (m *InfoType) String() string { return proto.CompactTextString(m) } |
| func (*InfoType) ProtoMessage() {} |
| func (*InfoType) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{0} |
| } |
| func (m *InfoType) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_InfoType.Unmarshal(m, b) |
| } |
| func (m *InfoType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_InfoType.Marshal(b, m, deterministic) |
| } |
| func (dst *InfoType) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_InfoType.Merge(dst, src) |
| } |
| func (m *InfoType) XXX_Size() int { |
| return xxx_messageInfo_InfoType.Size(m) |
| } |
| func (m *InfoType) XXX_DiscardUnknown() { |
| xxx_messageInfo_InfoType.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_InfoType proto.InternalMessageInfo |
| |
| func (m *InfoType) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| // A reference to a StoredInfoType to use with scanning. |
| type StoredType struct { |
| // Resource name of the requested `StoredInfoType`, for example |
| // `organizations/433245324/storedInfoTypes/432452342` or |
| // `projects/project-id/storedInfoTypes/432452342`. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| // Timestamp indicating when the version of the `StoredInfoType` used for |
| // inspection was created. Output-only field, populated by the system. |
| CreateTime *timestamp.Timestamp `protobuf:"bytes,2,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *StoredType) Reset() { *m = StoredType{} } |
| func (m *StoredType) String() string { return proto.CompactTextString(m) } |
| func (*StoredType) ProtoMessage() {} |
| func (*StoredType) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{1} |
| } |
| func (m *StoredType) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_StoredType.Unmarshal(m, b) |
| } |
| func (m *StoredType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_StoredType.Marshal(b, m, deterministic) |
| } |
| func (dst *StoredType) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_StoredType.Merge(dst, src) |
| } |
| func (m *StoredType) XXX_Size() int { |
| return xxx_messageInfo_StoredType.Size(m) |
| } |
| func (m *StoredType) XXX_DiscardUnknown() { |
| xxx_messageInfo_StoredType.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_StoredType proto.InternalMessageInfo |
| |
| func (m *StoredType) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| func (m *StoredType) GetCreateTime() *timestamp.Timestamp { |
| if m != nil { |
| return m.CreateTime |
| } |
| return nil |
| } |
| |
| // Custom information type provided by the user. Used to find domain-specific |
| // sensitive information configurable to the data in question. |
| type CustomInfoType struct { |
| // All CustomInfoTypes must have a name |
| // that does not conflict with built-in InfoTypes or other CustomInfoTypes. |
| InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType,proto3" json:"info_type,omitempty"` |
| // Likelihood to return for this CustomInfoType. This base value can be |
| // altered by a detection rule if the finding meets the criteria specified by |
| // the rule. Defaults to `VERY_LIKELY` if not specified. |
| Likelihood Likelihood `protobuf:"varint,6,opt,name=likelihood,proto3,enum=google.privacy.dlp.v2.Likelihood" json:"likelihood,omitempty"` |
| // Types that are valid to be assigned to Type: |
| // *CustomInfoType_Dictionary_ |
| // *CustomInfoType_Regex_ |
| // *CustomInfoType_SurrogateType_ |
| // *CustomInfoType_StoredType |
| Type isCustomInfoType_Type `protobuf_oneof:"type"` |
| // Set of detection rules to apply to all findings of this CustomInfoType. |
| // Rules are applied in order that they are specified. Not supported for the |
| // `surrogate_type` CustomInfoType. |
| DetectionRules []*CustomInfoType_DetectionRule `protobuf:"bytes,7,rep,name=detection_rules,json=detectionRules,proto3" json:"detection_rules,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType) Reset() { *m = CustomInfoType{} } |
| func (m *CustomInfoType) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType) ProtoMessage() {} |
| func (*CustomInfoType) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2} |
| } |
| func (m *CustomInfoType) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType.Merge(dst, src) |
| } |
| func (m *CustomInfoType) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType.Size(m) |
| } |
| func (m *CustomInfoType) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType proto.InternalMessageInfo |
| |
| func (m *CustomInfoType) GetInfoType() *InfoType { |
| if m != nil { |
| return m.InfoType |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetLikelihood() Likelihood { |
| if m != nil { |
| return m.Likelihood |
| } |
| return Likelihood_LIKELIHOOD_UNSPECIFIED |
| } |
| |
| type isCustomInfoType_Type interface { |
| isCustomInfoType_Type() |
| } |
| |
| type CustomInfoType_Dictionary_ struct { |
| Dictionary *CustomInfoType_Dictionary `protobuf:"bytes,2,opt,name=dictionary,proto3,oneof"` |
| } |
| |
| type CustomInfoType_Regex_ struct { |
| Regex *CustomInfoType_Regex `protobuf:"bytes,3,opt,name=regex,proto3,oneof"` |
| } |
| |
| type CustomInfoType_SurrogateType_ struct { |
| SurrogateType *CustomInfoType_SurrogateType `protobuf:"bytes,4,opt,name=surrogate_type,json=surrogateType,proto3,oneof"` |
| } |
| |
| type CustomInfoType_StoredType struct { |
| StoredType *StoredType `protobuf:"bytes,5,opt,name=stored_type,json=storedType,proto3,oneof"` |
| } |
| |
| func (*CustomInfoType_Dictionary_) isCustomInfoType_Type() {} |
| |
| func (*CustomInfoType_Regex_) isCustomInfoType_Type() {} |
| |
| func (*CustomInfoType_SurrogateType_) isCustomInfoType_Type() {} |
| |
| func (*CustomInfoType_StoredType) isCustomInfoType_Type() {} |
| |
| func (m *CustomInfoType) GetType() isCustomInfoType_Type { |
| if m != nil { |
| return m.Type |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetDictionary() *CustomInfoType_Dictionary { |
| if x, ok := m.GetType().(*CustomInfoType_Dictionary_); ok { |
| return x.Dictionary |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetRegex() *CustomInfoType_Regex { |
| if x, ok := m.GetType().(*CustomInfoType_Regex_); ok { |
| return x.Regex |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetSurrogateType() *CustomInfoType_SurrogateType { |
| if x, ok := m.GetType().(*CustomInfoType_SurrogateType_); ok { |
| return x.SurrogateType |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetStoredType() *StoredType { |
| if x, ok := m.GetType().(*CustomInfoType_StoredType); ok { |
| return x.StoredType |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType) GetDetectionRules() []*CustomInfoType_DetectionRule { |
| if m != nil { |
| return m.DetectionRules |
| } |
| return nil |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*CustomInfoType) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _CustomInfoType_OneofMarshaler, _CustomInfoType_OneofUnmarshaler, _CustomInfoType_OneofSizer, []interface{}{ |
| (*CustomInfoType_Dictionary_)(nil), |
| (*CustomInfoType_Regex_)(nil), |
| (*CustomInfoType_SurrogateType_)(nil), |
| (*CustomInfoType_StoredType)(nil), |
| } |
| } |
| |
| func _CustomInfoType_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*CustomInfoType) |
| // type |
| switch x := m.Type.(type) { |
| case *CustomInfoType_Dictionary_: |
| b.EncodeVarint(2<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.Dictionary); err != nil { |
| return err |
| } |
| case *CustomInfoType_Regex_: |
| b.EncodeVarint(3<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.Regex); err != nil { |
| return err |
| } |
| case *CustomInfoType_SurrogateType_: |
| b.EncodeVarint(4<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.SurrogateType); err != nil { |
| return err |
| } |
| case *CustomInfoType_StoredType: |
| b.EncodeVarint(5<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.StoredType); err != nil { |
| return err |
| } |
| case nil: |
| default: |
| return fmt.Errorf("CustomInfoType.Type has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _CustomInfoType_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*CustomInfoType) |
| switch tag { |
| case 2: // type.dictionary |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CustomInfoType_Dictionary) |
| err := b.DecodeMessage(msg) |
| m.Type = &CustomInfoType_Dictionary_{msg} |
| return true, err |
| case 3: // type.regex |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CustomInfoType_Regex) |
| err := b.DecodeMessage(msg) |
| m.Type = &CustomInfoType_Regex_{msg} |
| return true, err |
| case 4: // type.surrogate_type |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CustomInfoType_SurrogateType) |
| err := b.DecodeMessage(msg) |
| m.Type = &CustomInfoType_SurrogateType_{msg} |
| return true, err |
| case 5: // type.stored_type |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(StoredType) |
| err := b.DecodeMessage(msg) |
| m.Type = &CustomInfoType_StoredType{msg} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _CustomInfoType_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*CustomInfoType) |
| // type |
| switch x := m.Type.(type) { |
| case *CustomInfoType_Dictionary_: |
| s := proto.Size(x.Dictionary) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *CustomInfoType_Regex_: |
| s := proto.Size(x.Regex) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *CustomInfoType_SurrogateType_: |
| s := proto.Size(x.SurrogateType) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *CustomInfoType_StoredType: |
| s := proto.Size(x.StoredType) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Custom information type based on a dictionary of words or phrases. This can |
| // be used to match sensitive information specific to the data, such as a list |
| // of employee IDs or job titles. |
| // |
| // Dictionary words are case-insensitive and all characters other than letters |
| // and digits in the unicode [Basic Multilingual |
| // Plane](https://en.wikipedia.org/wiki/Plane_%28Unicode%29#Basic_Multilingual_Plane) |
| // will be replaced with whitespace when scanning for matches, so the |
| // dictionary phrase "Sam Johnson" will match all three phrases "sam johnson", |
| // "Sam, Johnson", and "Sam (Johnson)". Additionally, the characters |
| // surrounding any match must be of a different type than the adjacent |
| // characters within the word, so letters must be next to non-letters and |
| // digits next to non-digits. For example, the dictionary word "jen" will |
| // match the first three letters of the text "jen123" but will return no |
| // matches for "jennifer". |
| // |
| // Dictionary words containing a large number of characters that are not |
| // letters or digits may result in unexpected findings because such characters |
| // are treated as whitespace. The |
| // [limits](https://cloud.google.com/dlp/limits) page contains details about |
| // the size limits of dictionaries. For dictionaries that do not fit within |
| // these constraints, consider using `LargeCustomDictionaryConfig` in the |
| // `StoredInfoType` API. |
| type CustomInfoType_Dictionary struct { |
| // Types that are valid to be assigned to Source: |
| // *CustomInfoType_Dictionary_WordList_ |
| // *CustomInfoType_Dictionary_CloudStoragePath |
| Source isCustomInfoType_Dictionary_Source `protobuf_oneof:"source"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_Dictionary) Reset() { *m = CustomInfoType_Dictionary{} } |
| func (m *CustomInfoType_Dictionary) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_Dictionary) ProtoMessage() {} |
| func (*CustomInfoType_Dictionary) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 0} |
| } |
| func (m *CustomInfoType_Dictionary) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_Dictionary.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_Dictionary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_Dictionary.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_Dictionary) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_Dictionary.Merge(dst, src) |
| } |
| func (m *CustomInfoType_Dictionary) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_Dictionary.Size(m) |
| } |
| func (m *CustomInfoType_Dictionary) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_Dictionary.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_Dictionary proto.InternalMessageInfo |
| |
| type isCustomInfoType_Dictionary_Source interface { |
| isCustomInfoType_Dictionary_Source() |
| } |
| |
| type CustomInfoType_Dictionary_WordList_ struct { |
| WordList *CustomInfoType_Dictionary_WordList `protobuf:"bytes,1,opt,name=word_list,json=wordList,proto3,oneof"` |
| } |
| |
| type CustomInfoType_Dictionary_CloudStoragePath struct { |
| CloudStoragePath *CloudStoragePath `protobuf:"bytes,3,opt,name=cloud_storage_path,json=cloudStoragePath,proto3,oneof"` |
| } |
| |
| func (*CustomInfoType_Dictionary_WordList_) isCustomInfoType_Dictionary_Source() {} |
| |
| func (*CustomInfoType_Dictionary_CloudStoragePath) isCustomInfoType_Dictionary_Source() {} |
| |
| func (m *CustomInfoType_Dictionary) GetSource() isCustomInfoType_Dictionary_Source { |
| if m != nil { |
| return m.Source |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_Dictionary) GetWordList() *CustomInfoType_Dictionary_WordList { |
| if x, ok := m.GetSource().(*CustomInfoType_Dictionary_WordList_); ok { |
| return x.WordList |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_Dictionary) GetCloudStoragePath() *CloudStoragePath { |
| if x, ok := m.GetSource().(*CustomInfoType_Dictionary_CloudStoragePath); ok { |
| return x.CloudStoragePath |
| } |
| return nil |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*CustomInfoType_Dictionary) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _CustomInfoType_Dictionary_OneofMarshaler, _CustomInfoType_Dictionary_OneofUnmarshaler, _CustomInfoType_Dictionary_OneofSizer, []interface{}{ |
| (*CustomInfoType_Dictionary_WordList_)(nil), |
| (*CustomInfoType_Dictionary_CloudStoragePath)(nil), |
| } |
| } |
| |
| func _CustomInfoType_Dictionary_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*CustomInfoType_Dictionary) |
| // source |
| switch x := m.Source.(type) { |
| case *CustomInfoType_Dictionary_WordList_: |
| b.EncodeVarint(1<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.WordList); err != nil { |
| return err |
| } |
| case *CustomInfoType_Dictionary_CloudStoragePath: |
| b.EncodeVarint(3<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.CloudStoragePath); err != nil { |
| return err |
| } |
| case nil: |
| default: |
| return fmt.Errorf("CustomInfoType_Dictionary.Source has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _CustomInfoType_Dictionary_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*CustomInfoType_Dictionary) |
| switch tag { |
| case 1: // source.word_list |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CustomInfoType_Dictionary_WordList) |
| err := b.DecodeMessage(msg) |
| m.Source = &CustomInfoType_Dictionary_WordList_{msg} |
| return true, err |
| case 3: // source.cloud_storage_path |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CloudStoragePath) |
| err := b.DecodeMessage(msg) |
| m.Source = &CustomInfoType_Dictionary_CloudStoragePath{msg} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _CustomInfoType_Dictionary_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*CustomInfoType_Dictionary) |
| // source |
| switch x := m.Source.(type) { |
| case *CustomInfoType_Dictionary_WordList_: |
| s := proto.Size(x.WordList) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *CustomInfoType_Dictionary_CloudStoragePath: |
| s := proto.Size(x.CloudStoragePath) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Message defining a list of words or phrases to search for in the data. |
| type CustomInfoType_Dictionary_WordList struct { |
| // Words or phrases defining the dictionary. The dictionary must contain |
| // at least one phrase and every phrase must contain at least 2 characters |
| // that are letters or digits. [required] |
| Words []string `protobuf:"bytes,1,rep,name=words,proto3" json:"words,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_Dictionary_WordList) Reset() { *m = CustomInfoType_Dictionary_WordList{} } |
| func (m *CustomInfoType_Dictionary_WordList) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_Dictionary_WordList) ProtoMessage() {} |
| func (*CustomInfoType_Dictionary_WordList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 0, 0} |
| } |
| func (m *CustomInfoType_Dictionary_WordList) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_Dictionary_WordList.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_Dictionary_WordList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_Dictionary_WordList.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_Dictionary_WordList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_Dictionary_WordList.Merge(dst, src) |
| } |
| func (m *CustomInfoType_Dictionary_WordList) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_Dictionary_WordList.Size(m) |
| } |
| func (m *CustomInfoType_Dictionary_WordList) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_Dictionary_WordList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_Dictionary_WordList proto.InternalMessageInfo |
| |
| func (m *CustomInfoType_Dictionary_WordList) GetWords() []string { |
| if m != nil { |
| return m.Words |
| } |
| return nil |
| } |
| |
| // Message defining a custom regular expression. |
| type CustomInfoType_Regex struct { |
| // Pattern defining the regular expression. |
| Pattern string `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_Regex) Reset() { *m = CustomInfoType_Regex{} } |
| func (m *CustomInfoType_Regex) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_Regex) ProtoMessage() {} |
| func (*CustomInfoType_Regex) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 1} |
| } |
| func (m *CustomInfoType_Regex) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_Regex.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_Regex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_Regex.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_Regex) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_Regex.Merge(dst, src) |
| } |
| func (m *CustomInfoType_Regex) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_Regex.Size(m) |
| } |
| func (m *CustomInfoType_Regex) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_Regex.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_Regex proto.InternalMessageInfo |
| |
| func (m *CustomInfoType_Regex) GetPattern() string { |
| if m != nil { |
| return m.Pattern |
| } |
| return "" |
| } |
| |
| // Message for detecting output from deidentification transformations |
| // such as |
| // [`CryptoReplaceFfxFpeConfig`](/dlp/docs/reference/rest/v2/organizations.deidentifyTemplates#cryptoreplaceffxfpeconfig). |
| // These types of transformations are |
| // those that perform pseudonymization, thereby producing a "surrogate" as |
| // output. This should be used in conjunction with a field on the |
| // transformation such as `surrogate_info_type`. This CustomInfoType does |
| // not support the use of `detection_rules`. |
| type CustomInfoType_SurrogateType struct { |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_SurrogateType) Reset() { *m = CustomInfoType_SurrogateType{} } |
| func (m *CustomInfoType_SurrogateType) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_SurrogateType) ProtoMessage() {} |
| func (*CustomInfoType_SurrogateType) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 2} |
| } |
| func (m *CustomInfoType_SurrogateType) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_SurrogateType.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_SurrogateType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_SurrogateType.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_SurrogateType) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_SurrogateType.Merge(dst, src) |
| } |
| func (m *CustomInfoType_SurrogateType) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_SurrogateType.Size(m) |
| } |
| func (m *CustomInfoType_SurrogateType) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_SurrogateType.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_SurrogateType proto.InternalMessageInfo |
| |
| // Rule for modifying a CustomInfoType to alter behavior under certain |
| // circumstances, depending on the specific details of the rule. Not supported |
| // for the `surrogate_type` custom info type. |
| type CustomInfoType_DetectionRule struct { |
| // Types that are valid to be assigned to Type: |
| // *CustomInfoType_DetectionRule_HotwordRule_ |
| Type isCustomInfoType_DetectionRule_Type `protobuf_oneof:"type"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_DetectionRule) Reset() { *m = CustomInfoType_DetectionRule{} } |
| func (m *CustomInfoType_DetectionRule) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_DetectionRule) ProtoMessage() {} |
| func (*CustomInfoType_DetectionRule) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 3} |
| } |
| func (m *CustomInfoType_DetectionRule) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_DetectionRule.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_DetectionRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_DetectionRule.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_DetectionRule) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_DetectionRule.Merge(dst, src) |
| } |
| func (m *CustomInfoType_DetectionRule) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_DetectionRule.Size(m) |
| } |
| func (m *CustomInfoType_DetectionRule) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_DetectionRule.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_DetectionRule proto.InternalMessageInfo |
| |
| type isCustomInfoType_DetectionRule_Type interface { |
| isCustomInfoType_DetectionRule_Type() |
| } |
| |
| type CustomInfoType_DetectionRule_HotwordRule_ struct { |
| HotwordRule *CustomInfoType_DetectionRule_HotwordRule `protobuf:"bytes,1,opt,name=hotword_rule,json=hotwordRule,proto3,oneof"` |
| } |
| |
| func (*CustomInfoType_DetectionRule_HotwordRule_) isCustomInfoType_DetectionRule_Type() {} |
| |
| func (m *CustomInfoType_DetectionRule) GetType() isCustomInfoType_DetectionRule_Type { |
| if m != nil { |
| return m.Type |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_DetectionRule) GetHotwordRule() *CustomInfoType_DetectionRule_HotwordRule { |
| if x, ok := m.GetType().(*CustomInfoType_DetectionRule_HotwordRule_); ok { |
| return x.HotwordRule |
| } |
| return nil |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*CustomInfoType_DetectionRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _CustomInfoType_DetectionRule_OneofMarshaler, _CustomInfoType_DetectionRule_OneofUnmarshaler, _CustomInfoType_DetectionRule_OneofSizer, []interface{}{ |
| (*CustomInfoType_DetectionRule_HotwordRule_)(nil), |
| } |
| } |
| |
| func _CustomInfoType_DetectionRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*CustomInfoType_DetectionRule) |
| // type |
| switch x := m.Type.(type) { |
| case *CustomInfoType_DetectionRule_HotwordRule_: |
| b.EncodeVarint(1<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.HotwordRule); err != nil { |
| return err |
| } |
| case nil: |
| default: |
| return fmt.Errorf("CustomInfoType_DetectionRule.Type has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _CustomInfoType_DetectionRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*CustomInfoType_DetectionRule) |
| switch tag { |
| case 1: // type.hotword_rule |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CustomInfoType_DetectionRule_HotwordRule) |
| err := b.DecodeMessage(msg) |
| m.Type = &CustomInfoType_DetectionRule_HotwordRule_{msg} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _CustomInfoType_DetectionRule_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*CustomInfoType_DetectionRule) |
| // type |
| switch x := m.Type.(type) { |
| case *CustomInfoType_DetectionRule_HotwordRule_: |
| s := proto.Size(x.HotwordRule) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Message for specifying a window around a finding to apply a detection |
| // rule. |
| type CustomInfoType_DetectionRule_Proximity struct { |
| // Number of characters before the finding to consider. |
| WindowBefore int32 `protobuf:"varint,1,opt,name=window_before,json=windowBefore,proto3" json:"window_before,omitempty"` |
| // Number of characters after the finding to consider. |
| WindowAfter int32 `protobuf:"varint,2,opt,name=window_after,json=windowAfter,proto3" json:"window_after,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_DetectionRule_Proximity) Reset() { |
| *m = CustomInfoType_DetectionRule_Proximity{} |
| } |
| func (m *CustomInfoType_DetectionRule_Proximity) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_DetectionRule_Proximity) ProtoMessage() {} |
| func (*CustomInfoType_DetectionRule_Proximity) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 3, 0} |
| } |
| func (m *CustomInfoType_DetectionRule_Proximity) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_Proximity.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_DetectionRule_Proximity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_Proximity.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_DetectionRule_Proximity) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_DetectionRule_Proximity.Merge(dst, src) |
| } |
| func (m *CustomInfoType_DetectionRule_Proximity) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_Proximity.Size(m) |
| } |
| func (m *CustomInfoType_DetectionRule_Proximity) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_DetectionRule_Proximity.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_DetectionRule_Proximity proto.InternalMessageInfo |
| |
| func (m *CustomInfoType_DetectionRule_Proximity) GetWindowBefore() int32 { |
| if m != nil { |
| return m.WindowBefore |
| } |
| return 0 |
| } |
| |
| func (m *CustomInfoType_DetectionRule_Proximity) GetWindowAfter() int32 { |
| if m != nil { |
| return m.WindowAfter |
| } |
| return 0 |
| } |
| |
| // Message for specifying an adjustment to the likelihood of a finding as |
| // part of a detection rule. |
| type CustomInfoType_DetectionRule_LikelihoodAdjustment struct { |
| // Types that are valid to be assigned to Adjustment: |
| // *CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood |
| // *CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood |
| Adjustment isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment `protobuf_oneof:"adjustment"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) Reset() { |
| *m = CustomInfoType_DetectionRule_LikelihoodAdjustment{} |
| } |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) String() string { |
| return proto.CompactTextString(m) |
| } |
| func (*CustomInfoType_DetectionRule_LikelihoodAdjustment) ProtoMessage() {} |
| func (*CustomInfoType_DetectionRule_LikelihoodAdjustment) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 3, 1} |
| } |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment.Merge(dst, src) |
| } |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment.Size(m) |
| } |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_DetectionRule_LikelihoodAdjustment proto.InternalMessageInfo |
| |
| type isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment interface { |
| isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment() |
| } |
| |
| type CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood struct { |
| FixedLikelihood Likelihood `protobuf:"varint,1,opt,name=fixed_likelihood,json=fixedLikelihood,proto3,enum=google.privacy.dlp.v2.Likelihood,oneof"` |
| } |
| |
| type CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood struct { |
| RelativeLikelihood int32 `protobuf:"varint,2,opt,name=relative_likelihood,json=relativeLikelihood,proto3,oneof"` |
| } |
| |
| func (*CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood) isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment() { |
| } |
| |
| func (*CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood) isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment() { |
| } |
| |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) GetAdjustment() isCustomInfoType_DetectionRule_LikelihoodAdjustment_Adjustment { |
| if m != nil { |
| return m.Adjustment |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) GetFixedLikelihood() Likelihood { |
| if x, ok := m.GetAdjustment().(*CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood); ok { |
| return x.FixedLikelihood |
| } |
| return Likelihood_LIKELIHOOD_UNSPECIFIED |
| } |
| |
| func (m *CustomInfoType_DetectionRule_LikelihoodAdjustment) GetRelativeLikelihood() int32 { |
| if x, ok := m.GetAdjustment().(*CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood); ok { |
| return x.RelativeLikelihood |
| } |
| return 0 |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*CustomInfoType_DetectionRule_LikelihoodAdjustment) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofMarshaler, _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofUnmarshaler, _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofSizer, []interface{}{ |
| (*CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood)(nil), |
| (*CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood)(nil), |
| } |
| } |
| |
| func _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*CustomInfoType_DetectionRule_LikelihoodAdjustment) |
| // adjustment |
| switch x := m.Adjustment.(type) { |
| case *CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood: |
| b.EncodeVarint(1<<3 | proto.WireVarint) |
| b.EncodeVarint(uint64(x.FixedLikelihood)) |
| case *CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood: |
| b.EncodeVarint(2<<3 | proto.WireVarint) |
| b.EncodeVarint(uint64(x.RelativeLikelihood)) |
| case nil: |
| default: |
| return fmt.Errorf("CustomInfoType_DetectionRule_LikelihoodAdjustment.Adjustment has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*CustomInfoType_DetectionRule_LikelihoodAdjustment) |
| switch tag { |
| case 1: // adjustment.fixed_likelihood |
| if wire != proto.WireVarint { |
| return true, proto.ErrInternalBadWireType |
| } |
| x, err := b.DecodeVarint() |
| m.Adjustment = &CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood{Likelihood(x)} |
| return true, err |
| case 2: // adjustment.relative_likelihood |
| if wire != proto.WireVarint { |
| return true, proto.ErrInternalBadWireType |
| } |
| x, err := b.DecodeVarint() |
| m.Adjustment = &CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood{int32(x)} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _CustomInfoType_DetectionRule_LikelihoodAdjustment_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*CustomInfoType_DetectionRule_LikelihoodAdjustment) |
| // adjustment |
| switch x := m.Adjustment.(type) { |
| case *CustomInfoType_DetectionRule_LikelihoodAdjustment_FixedLikelihood: |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(x.FixedLikelihood)) |
| case *CustomInfoType_DetectionRule_LikelihoodAdjustment_RelativeLikelihood: |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(x.RelativeLikelihood)) |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // The rule that adjusts the likelihood of findings within a certain |
| // proximity of hotwords. |
| type CustomInfoType_DetectionRule_HotwordRule struct { |
| // Regular expression pattern defining what qualifies as a hotword. |
| HotwordRegex *CustomInfoType_Regex `protobuf:"bytes,1,opt,name=hotword_regex,json=hotwordRegex,proto3" json:"hotword_regex,omitempty"` |
| // Proximity of the finding within which the entire hotword must reside. |
| // The total length of the window cannot exceed 1000 characters. Note that |
| // the finding itself will be included in the window, so that hotwords may |
| // be used to match substrings of the finding itself. For example, the |
| // certainty of a phone number regex "\(\d{3}\) \d{3}-\d{4}" could be |
| // adjusted upwards if the area code is known to be the local area code of |
| // a company office using the hotword regex "\(xxx\)", where "xxx" |
| // is the area code in question. |
| Proximity *CustomInfoType_DetectionRule_Proximity `protobuf:"bytes,2,opt,name=proximity,proto3" json:"proximity,omitempty"` |
| // Likelihood adjustment to apply to all matching findings. |
| LikelihoodAdjustment *CustomInfoType_DetectionRule_LikelihoodAdjustment `protobuf:"bytes,3,opt,name=likelihood_adjustment,json=likelihoodAdjustment,proto3" json:"likelihood_adjustment,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CustomInfoType_DetectionRule_HotwordRule) Reset() { |
| *m = CustomInfoType_DetectionRule_HotwordRule{} |
| } |
| func (m *CustomInfoType_DetectionRule_HotwordRule) String() string { return proto.CompactTextString(m) } |
| func (*CustomInfoType_DetectionRule_HotwordRule) ProtoMessage() {} |
| func (*CustomInfoType_DetectionRule_HotwordRule) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{2, 3, 2} |
| } |
| func (m *CustomInfoType_DetectionRule_HotwordRule) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule.Unmarshal(m, b) |
| } |
| func (m *CustomInfoType_DetectionRule_HotwordRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule.Marshal(b, m, deterministic) |
| } |
| func (dst *CustomInfoType_DetectionRule_HotwordRule) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule.Merge(dst, src) |
| } |
| func (m *CustomInfoType_DetectionRule_HotwordRule) XXX_Size() int { |
| return xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule.Size(m) |
| } |
| func (m *CustomInfoType_DetectionRule_HotwordRule) XXX_DiscardUnknown() { |
| xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CustomInfoType_DetectionRule_HotwordRule proto.InternalMessageInfo |
| |
| func (m *CustomInfoType_DetectionRule_HotwordRule) GetHotwordRegex() *CustomInfoType_Regex { |
| if m != nil { |
| return m.HotwordRegex |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_DetectionRule_HotwordRule) GetProximity() *CustomInfoType_DetectionRule_Proximity { |
| if m != nil { |
| return m.Proximity |
| } |
| return nil |
| } |
| |
| func (m *CustomInfoType_DetectionRule_HotwordRule) GetLikelihoodAdjustment() *CustomInfoType_DetectionRule_LikelihoodAdjustment { |
| if m != nil { |
| return m.LikelihoodAdjustment |
| } |
| return nil |
| } |
| |
| // General identifier of a data field in a storage service. |
| type FieldId struct { |
| // Name describing the field. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *FieldId) Reset() { *m = FieldId{} } |
| func (m *FieldId) String() string { return proto.CompactTextString(m) } |
| func (*FieldId) ProtoMessage() {} |
| func (*FieldId) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{3} |
| } |
| func (m *FieldId) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_FieldId.Unmarshal(m, b) |
| } |
| func (m *FieldId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_FieldId.Marshal(b, m, deterministic) |
| } |
| func (dst *FieldId) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FieldId.Merge(dst, src) |
| } |
| func (m *FieldId) XXX_Size() int { |
| return xxx_messageInfo_FieldId.Size(m) |
| } |
| func (m *FieldId) XXX_DiscardUnknown() { |
| xxx_messageInfo_FieldId.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FieldId proto.InternalMessageInfo |
| |
| func (m *FieldId) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| // Datastore partition ID. |
| // A partition ID identifies a grouping of entities. The grouping is always |
| // by project and namespace, however the namespace ID may be empty. |
| // |
| // A partition ID contains several dimensions: |
| // project ID and namespace ID. |
| type PartitionId struct { |
| // The ID of the project to which the entities belong. |
| ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` |
| // If not empty, the ID of the namespace to which the entities belong. |
| NamespaceId string `protobuf:"bytes,4,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *PartitionId) Reset() { *m = PartitionId{} } |
| func (m *PartitionId) String() string { return proto.CompactTextString(m) } |
| func (*PartitionId) ProtoMessage() {} |
| func (*PartitionId) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{4} |
| } |
| func (m *PartitionId) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_PartitionId.Unmarshal(m, b) |
| } |
| func (m *PartitionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_PartitionId.Marshal(b, m, deterministic) |
| } |
| func (dst *PartitionId) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PartitionId.Merge(dst, src) |
| } |
| func (m *PartitionId) XXX_Size() int { |
| return xxx_messageInfo_PartitionId.Size(m) |
| } |
| func (m *PartitionId) XXX_DiscardUnknown() { |
| xxx_messageInfo_PartitionId.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PartitionId proto.InternalMessageInfo |
| |
| func (m *PartitionId) GetProjectId() string { |
| if m != nil { |
| return m.ProjectId |
| } |
| return "" |
| } |
| |
| func (m *PartitionId) GetNamespaceId() string { |
| if m != nil { |
| return m.NamespaceId |
| } |
| return "" |
| } |
| |
| // A representation of a Datastore kind. |
| type KindExpression struct { |
| // The name of the kind. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *KindExpression) Reset() { *m = KindExpression{} } |
| func (m *KindExpression) String() string { return proto.CompactTextString(m) } |
| func (*KindExpression) ProtoMessage() {} |
| func (*KindExpression) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{5} |
| } |
| func (m *KindExpression) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_KindExpression.Unmarshal(m, b) |
| } |
| func (m *KindExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_KindExpression.Marshal(b, m, deterministic) |
| } |
| func (dst *KindExpression) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_KindExpression.Merge(dst, src) |
| } |
| func (m *KindExpression) XXX_Size() int { |
| return xxx_messageInfo_KindExpression.Size(m) |
| } |
| func (m *KindExpression) XXX_DiscardUnknown() { |
| xxx_messageInfo_KindExpression.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_KindExpression proto.InternalMessageInfo |
| |
| func (m *KindExpression) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| // Options defining a data set within Google Cloud Datastore. |
| type DatastoreOptions struct { |
| // A partition ID identifies a grouping of entities. The grouping is always |
| // by project and namespace, however the namespace ID may be empty. |
| PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"` |
| // The kind to process. |
| Kind *KindExpression `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *DatastoreOptions) Reset() { *m = DatastoreOptions{} } |
| func (m *DatastoreOptions) String() string { return proto.CompactTextString(m) } |
| func (*DatastoreOptions) ProtoMessage() {} |
| func (*DatastoreOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{6} |
| } |
| func (m *DatastoreOptions) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_DatastoreOptions.Unmarshal(m, b) |
| } |
| func (m *DatastoreOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_DatastoreOptions.Marshal(b, m, deterministic) |
| } |
| func (dst *DatastoreOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DatastoreOptions.Merge(dst, src) |
| } |
| func (m *DatastoreOptions) XXX_Size() int { |
| return xxx_messageInfo_DatastoreOptions.Size(m) |
| } |
| func (m *DatastoreOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_DatastoreOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DatastoreOptions proto.InternalMessageInfo |
| |
| func (m *DatastoreOptions) GetPartitionId() *PartitionId { |
| if m != nil { |
| return m.PartitionId |
| } |
| return nil |
| } |
| |
| func (m *DatastoreOptions) GetKind() *KindExpression { |
| if m != nil { |
| return m.Kind |
| } |
| return nil |
| } |
| |
| // Options defining a file or a set of files (path ending with *) within |
| // a Google Cloud Storage bucket. |
| type CloudStorageOptions struct { |
| FileSet *CloudStorageOptions_FileSet `protobuf:"bytes,1,opt,name=file_set,json=fileSet,proto3" json:"file_set,omitempty"` |
| // Max number of bytes to scan from a file. If a scanned file's size is bigger |
| // than this value then the rest of the bytes are omitted. Only one |
| // of bytes_limit_per_file and bytes_limit_per_file_percent can be specified. |
| BytesLimitPerFile int64 `protobuf:"varint,4,opt,name=bytes_limit_per_file,json=bytesLimitPerFile,proto3" json:"bytes_limit_per_file,omitempty"` |
| // Max percentage of bytes to scan from a file. The rest are omitted. The |
| // number of bytes scanned is rounded down. Must be between 0 and 100, |
| // inclusively. Both 0 and 100 means no limit. Defaults to 0. Only one |
| // of bytes_limit_per_file and bytes_limit_per_file_percent can be specified. |
| BytesLimitPerFilePercent int32 `protobuf:"varint,8,opt,name=bytes_limit_per_file_percent,json=bytesLimitPerFilePercent,proto3" json:"bytes_limit_per_file_percent,omitempty"` |
| // List of file type groups to include in the scan. |
| // If empty, all files are scanned and available data format processors |
| // are applied. |
| FileTypes []FileType `protobuf:"varint,5,rep,packed,name=file_types,json=fileTypes,proto3,enum=google.privacy.dlp.v2.FileType" json:"file_types,omitempty"` |
| SampleMethod CloudStorageOptions_SampleMethod `protobuf:"varint,6,opt,name=sample_method,json=sampleMethod,proto3,enum=google.privacy.dlp.v2.CloudStorageOptions_SampleMethod" json:"sample_method,omitempty"` |
| // Limits the number of files to scan to this percentage of the input FileSet. |
| // Number of files scanned is rounded down. Must be between 0 and 100, |
| // inclusively. Both 0 and 100 means no limit. Defaults to 0. |
| FilesLimitPercent int32 `protobuf:"varint,7,opt,name=files_limit_percent,json=filesLimitPercent,proto3" json:"files_limit_percent,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CloudStorageOptions) Reset() { *m = CloudStorageOptions{} } |
| func (m *CloudStorageOptions) String() string { return proto.CompactTextString(m) } |
| func (*CloudStorageOptions) ProtoMessage() {} |
| func (*CloudStorageOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{7} |
| } |
| func (m *CloudStorageOptions) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CloudStorageOptions.Unmarshal(m, b) |
| } |
| func (m *CloudStorageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CloudStorageOptions.Marshal(b, m, deterministic) |
| } |
| func (dst *CloudStorageOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CloudStorageOptions.Merge(dst, src) |
| } |
| func (m *CloudStorageOptions) XXX_Size() int { |
| return xxx_messageInfo_CloudStorageOptions.Size(m) |
| } |
| func (m *CloudStorageOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_CloudStorageOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CloudStorageOptions proto.InternalMessageInfo |
| |
| func (m *CloudStorageOptions) GetFileSet() *CloudStorageOptions_FileSet { |
| if m != nil { |
| return m.FileSet |
| } |
| return nil |
| } |
| |
| func (m *CloudStorageOptions) GetBytesLimitPerFile() int64 { |
| if m != nil { |
| return m.BytesLimitPerFile |
| } |
| return 0 |
| } |
| |
| func (m *CloudStorageOptions) GetBytesLimitPerFilePercent() int32 { |
| if m != nil { |
| return m.BytesLimitPerFilePercent |
| } |
| return 0 |
| } |
| |
| func (m *CloudStorageOptions) GetFileTypes() []FileType { |
| if m != nil { |
| return m.FileTypes |
| } |
| return nil |
| } |
| |
| func (m *CloudStorageOptions) GetSampleMethod() CloudStorageOptions_SampleMethod { |
| if m != nil { |
| return m.SampleMethod |
| } |
| return CloudStorageOptions_SAMPLE_METHOD_UNSPECIFIED |
| } |
| |
| func (m *CloudStorageOptions) GetFilesLimitPercent() int32 { |
| if m != nil { |
| return m.FilesLimitPercent |
| } |
| return 0 |
| } |
| |
| // Set of files to scan. |
| type CloudStorageOptions_FileSet struct { |
| // The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the |
| // path is allowed. |
| Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CloudStorageOptions_FileSet) Reset() { *m = CloudStorageOptions_FileSet{} } |
| func (m *CloudStorageOptions_FileSet) String() string { return proto.CompactTextString(m) } |
| func (*CloudStorageOptions_FileSet) ProtoMessage() {} |
| func (*CloudStorageOptions_FileSet) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{7, 0} |
| } |
| func (m *CloudStorageOptions_FileSet) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CloudStorageOptions_FileSet.Unmarshal(m, b) |
| } |
| func (m *CloudStorageOptions_FileSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CloudStorageOptions_FileSet.Marshal(b, m, deterministic) |
| } |
| func (dst *CloudStorageOptions_FileSet) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CloudStorageOptions_FileSet.Merge(dst, src) |
| } |
| func (m *CloudStorageOptions_FileSet) XXX_Size() int { |
| return xxx_messageInfo_CloudStorageOptions_FileSet.Size(m) |
| } |
| func (m *CloudStorageOptions_FileSet) XXX_DiscardUnknown() { |
| xxx_messageInfo_CloudStorageOptions_FileSet.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CloudStorageOptions_FileSet proto.InternalMessageInfo |
| |
| func (m *CloudStorageOptions_FileSet) GetUrl() string { |
| if m != nil { |
| return m.Url |
| } |
| return "" |
| } |
| |
| // Message representing a set of files in Cloud Storage. |
| type CloudStorageFileSet struct { |
| // The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the |
| // path is allowed. |
| Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CloudStorageFileSet) Reset() { *m = CloudStorageFileSet{} } |
| func (m *CloudStorageFileSet) String() string { return proto.CompactTextString(m) } |
| func (*CloudStorageFileSet) ProtoMessage() {} |
| func (*CloudStorageFileSet) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{8} |
| } |
| func (m *CloudStorageFileSet) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CloudStorageFileSet.Unmarshal(m, b) |
| } |
| func (m *CloudStorageFileSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CloudStorageFileSet.Marshal(b, m, deterministic) |
| } |
| func (dst *CloudStorageFileSet) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CloudStorageFileSet.Merge(dst, src) |
| } |
| func (m *CloudStorageFileSet) XXX_Size() int { |
| return xxx_messageInfo_CloudStorageFileSet.Size(m) |
| } |
| func (m *CloudStorageFileSet) XXX_DiscardUnknown() { |
| xxx_messageInfo_CloudStorageFileSet.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CloudStorageFileSet proto.InternalMessageInfo |
| |
| func (m *CloudStorageFileSet) GetUrl() string { |
| if m != nil { |
| return m.Url |
| } |
| return "" |
| } |
| |
| // Message representing a single file or path in Cloud Storage. |
| type CloudStoragePath struct { |
| // A url representing a file or path (no wildcards) in Cloud Storage. |
| // Example: gs://[BUCKET_NAME]/dictionary.txt |
| Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CloudStoragePath) Reset() { *m = CloudStoragePath{} } |
| func (m *CloudStoragePath) String() string { return proto.CompactTextString(m) } |
| func (*CloudStoragePath) ProtoMessage() {} |
| func (*CloudStoragePath) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{9} |
| } |
| func (m *CloudStoragePath) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CloudStoragePath.Unmarshal(m, b) |
| } |
| func (m *CloudStoragePath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CloudStoragePath.Marshal(b, m, deterministic) |
| } |
| func (dst *CloudStoragePath) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CloudStoragePath.Merge(dst, src) |
| } |
| func (m *CloudStoragePath) XXX_Size() int { |
| return xxx_messageInfo_CloudStoragePath.Size(m) |
| } |
| func (m *CloudStoragePath) XXX_DiscardUnknown() { |
| xxx_messageInfo_CloudStoragePath.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CloudStoragePath proto.InternalMessageInfo |
| |
| func (m *CloudStoragePath) GetPath() string { |
| if m != nil { |
| return m.Path |
| } |
| return "" |
| } |
| |
| // Options defining BigQuery table and row identifiers. |
| type BigQueryOptions struct { |
| // Complete BigQuery table reference. |
| TableReference *BigQueryTable `protobuf:"bytes,1,opt,name=table_reference,json=tableReference,proto3" json:"table_reference,omitempty"` |
| // References to fields uniquely identifying rows within the table. |
| // Nested fields in the format, like `person.birthdate.year`, are allowed. |
| IdentifyingFields []*FieldId `protobuf:"bytes,2,rep,name=identifying_fields,json=identifyingFields,proto3" json:"identifying_fields,omitempty"` |
| // Max number of rows to scan. If the table has more rows than this value, the |
| // rest of the rows are omitted. If not set, or if set to 0, all rows will be |
| // scanned. Only one of rows_limit and rows_limit_percent can be specified. |
| // Cannot be used in conjunction with TimespanConfig. |
| RowsLimit int64 `protobuf:"varint,3,opt,name=rows_limit,json=rowsLimit,proto3" json:"rows_limit,omitempty"` |
| // Max percentage of rows to scan. The rest are omitted. The number of rows |
| // scanned is rounded down. Must be between 0 and 100, inclusively. Both 0 and |
| // 100 means no limit. Defaults to 0. Only one of rows_limit and |
| // rows_limit_percent can be specified. Cannot be used in conjunction with |
| // TimespanConfig. |
| RowsLimitPercent int32 `protobuf:"varint,6,opt,name=rows_limit_percent,json=rowsLimitPercent,proto3" json:"rows_limit_percent,omitempty"` |
| SampleMethod BigQueryOptions_SampleMethod `protobuf:"varint,4,opt,name=sample_method,json=sampleMethod,proto3,enum=google.privacy.dlp.v2.BigQueryOptions_SampleMethod" json:"sample_method,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BigQueryOptions) Reset() { *m = BigQueryOptions{} } |
| func (m *BigQueryOptions) String() string { return proto.CompactTextString(m) } |
| func (*BigQueryOptions) ProtoMessage() {} |
| func (*BigQueryOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{10} |
| } |
| func (m *BigQueryOptions) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BigQueryOptions.Unmarshal(m, b) |
| } |
| func (m *BigQueryOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BigQueryOptions.Marshal(b, m, deterministic) |
| } |
| func (dst *BigQueryOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BigQueryOptions.Merge(dst, src) |
| } |
| func (m *BigQueryOptions) XXX_Size() int { |
| return xxx_messageInfo_BigQueryOptions.Size(m) |
| } |
| func (m *BigQueryOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_BigQueryOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BigQueryOptions proto.InternalMessageInfo |
| |
| func (m *BigQueryOptions) GetTableReference() *BigQueryTable { |
| if m != nil { |
| return m.TableReference |
| } |
| return nil |
| } |
| |
| func (m *BigQueryOptions) GetIdentifyingFields() []*FieldId { |
| if m != nil { |
| return m.IdentifyingFields |
| } |
| return nil |
| } |
| |
| func (m *BigQueryOptions) GetRowsLimit() int64 { |
| if m != nil { |
| return m.RowsLimit |
| } |
| return 0 |
| } |
| |
| func (m *BigQueryOptions) GetRowsLimitPercent() int32 { |
| if m != nil { |
| return m.RowsLimitPercent |
| } |
| return 0 |
| } |
| |
| func (m *BigQueryOptions) GetSampleMethod() BigQueryOptions_SampleMethod { |
| if m != nil { |
| return m.SampleMethod |
| } |
| return BigQueryOptions_SAMPLE_METHOD_UNSPECIFIED |
| } |
| |
| // Shared message indicating Cloud storage type. |
| type StorageConfig struct { |
| // Types that are valid to be assigned to Type: |
| // *StorageConfig_DatastoreOptions |
| // *StorageConfig_CloudStorageOptions |
| // *StorageConfig_BigQueryOptions |
| Type isStorageConfig_Type `protobuf_oneof:"type"` |
| TimespanConfig *StorageConfig_TimespanConfig `protobuf:"bytes,6,opt,name=timespan_config,json=timespanConfig,proto3" json:"timespan_config,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *StorageConfig) Reset() { *m = StorageConfig{} } |
| func (m *StorageConfig) String() string { return proto.CompactTextString(m) } |
| func (*StorageConfig) ProtoMessage() {} |
| func (*StorageConfig) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{11} |
| } |
| func (m *StorageConfig) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_StorageConfig.Unmarshal(m, b) |
| } |
| func (m *StorageConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_StorageConfig.Marshal(b, m, deterministic) |
| } |
| func (dst *StorageConfig) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_StorageConfig.Merge(dst, src) |
| } |
| func (m *StorageConfig) XXX_Size() int { |
| return xxx_messageInfo_StorageConfig.Size(m) |
| } |
| func (m *StorageConfig) XXX_DiscardUnknown() { |
| xxx_messageInfo_StorageConfig.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_StorageConfig proto.InternalMessageInfo |
| |
| type isStorageConfig_Type interface { |
| isStorageConfig_Type() |
| } |
| |
| type StorageConfig_DatastoreOptions struct { |
| DatastoreOptions *DatastoreOptions `protobuf:"bytes,2,opt,name=datastore_options,json=datastoreOptions,proto3,oneof"` |
| } |
| |
| type StorageConfig_CloudStorageOptions struct { |
| CloudStorageOptions *CloudStorageOptions `protobuf:"bytes,3,opt,name=cloud_storage_options,json=cloudStorageOptions,proto3,oneof"` |
| } |
| |
| type StorageConfig_BigQueryOptions struct { |
| BigQueryOptions *BigQueryOptions `protobuf:"bytes,4,opt,name=big_query_options,json=bigQueryOptions,proto3,oneof"` |
| } |
| |
| func (*StorageConfig_DatastoreOptions) isStorageConfig_Type() {} |
| |
| func (*StorageConfig_CloudStorageOptions) isStorageConfig_Type() {} |
| |
| func (*StorageConfig_BigQueryOptions) isStorageConfig_Type() {} |
| |
| func (m *StorageConfig) GetType() isStorageConfig_Type { |
| if m != nil { |
| return m.Type |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig) GetDatastoreOptions() *DatastoreOptions { |
| if x, ok := m.GetType().(*StorageConfig_DatastoreOptions); ok { |
| return x.DatastoreOptions |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig) GetCloudStorageOptions() *CloudStorageOptions { |
| if x, ok := m.GetType().(*StorageConfig_CloudStorageOptions); ok { |
| return x.CloudStorageOptions |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig) GetBigQueryOptions() *BigQueryOptions { |
| if x, ok := m.GetType().(*StorageConfig_BigQueryOptions); ok { |
| return x.BigQueryOptions |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig) GetTimespanConfig() *StorageConfig_TimespanConfig { |
| if m != nil { |
| return m.TimespanConfig |
| } |
| return nil |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*StorageConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _StorageConfig_OneofMarshaler, _StorageConfig_OneofUnmarshaler, _StorageConfig_OneofSizer, []interface{}{ |
| (*StorageConfig_DatastoreOptions)(nil), |
| (*StorageConfig_CloudStorageOptions)(nil), |
| (*StorageConfig_BigQueryOptions)(nil), |
| } |
| } |
| |
| func _StorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*StorageConfig) |
| // type |
| switch x := m.Type.(type) { |
| case *StorageConfig_DatastoreOptions: |
| b.EncodeVarint(2<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.DatastoreOptions); err != nil { |
| return err |
| } |
| case *StorageConfig_CloudStorageOptions: |
| b.EncodeVarint(3<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.CloudStorageOptions); err != nil { |
| return err |
| } |
| case *StorageConfig_BigQueryOptions: |
| b.EncodeVarint(4<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.BigQueryOptions); err != nil { |
| return err |
| } |
| case nil: |
| default: |
| return fmt.Errorf("StorageConfig.Type has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _StorageConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*StorageConfig) |
| switch tag { |
| case 2: // type.datastore_options |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(DatastoreOptions) |
| err := b.DecodeMessage(msg) |
| m.Type = &StorageConfig_DatastoreOptions{msg} |
| return true, err |
| case 3: // type.cloud_storage_options |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(CloudStorageOptions) |
| err := b.DecodeMessage(msg) |
| m.Type = &StorageConfig_CloudStorageOptions{msg} |
| return true, err |
| case 4: // type.big_query_options |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(BigQueryOptions) |
| err := b.DecodeMessage(msg) |
| m.Type = &StorageConfig_BigQueryOptions{msg} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _StorageConfig_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*StorageConfig) |
| // type |
| switch x := m.Type.(type) { |
| case *StorageConfig_DatastoreOptions: |
| s := proto.Size(x.DatastoreOptions) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *StorageConfig_CloudStorageOptions: |
| s := proto.Size(x.CloudStorageOptions) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *StorageConfig_BigQueryOptions: |
| s := proto.Size(x.BigQueryOptions) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Configuration of the timespan of the items to include in scanning. |
| // Currently only supported when inspecting Google Cloud Storage and BigQuery. |
| type StorageConfig_TimespanConfig struct { |
| // Exclude files or rows older than this value. |
| StartTime *timestamp.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` |
| // Exclude files or rows newer than this value. |
| // If set to zero, no upper time limit is applied. |
| EndTime *timestamp.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` |
| // Specification of the field containing the timestamp of scanned items. |
| // Used for data sources like Datastore or BigQuery. |
| // If not specified for BigQuery, table last modification timestamp |
| // is checked against given time span. |
| // The valid data types of the timestamp field are: |
| // for BigQuery - timestamp, date, datetime; |
| // for Datastore - timestamp. |
| // Datastore entity will be scanned if the timestamp property does not exist |
| // or its value is empty or invalid. |
| TimestampField *FieldId `protobuf:"bytes,3,opt,name=timestamp_field,json=timestampField,proto3" json:"timestamp_field,omitempty"` |
| // When the job is started by a JobTrigger we will automatically figure out |
| // a valid start_time to avoid scanning files that have not been modified |
| // since the last time the JobTrigger executed. This will be based on the |
| // time of the execution of the last run of the JobTrigger. |
| EnableAutoPopulationOfTimespanConfig bool `protobuf:"varint,4,opt,name=enable_auto_population_of_timespan_config,json=enableAutoPopulationOfTimespanConfig,proto3" json:"enable_auto_population_of_timespan_config,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *StorageConfig_TimespanConfig) Reset() { *m = StorageConfig_TimespanConfig{} } |
| func (m *StorageConfig_TimespanConfig) String() string { return proto.CompactTextString(m) } |
| func (*StorageConfig_TimespanConfig) ProtoMessage() {} |
| func (*StorageConfig_TimespanConfig) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{11, 0} |
| } |
| func (m *StorageConfig_TimespanConfig) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_StorageConfig_TimespanConfig.Unmarshal(m, b) |
| } |
| func (m *StorageConfig_TimespanConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_StorageConfig_TimespanConfig.Marshal(b, m, deterministic) |
| } |
| func (dst *StorageConfig_TimespanConfig) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_StorageConfig_TimespanConfig.Merge(dst, src) |
| } |
| func (m *StorageConfig_TimespanConfig) XXX_Size() int { |
| return xxx_messageInfo_StorageConfig_TimespanConfig.Size(m) |
| } |
| func (m *StorageConfig_TimespanConfig) XXX_DiscardUnknown() { |
| xxx_messageInfo_StorageConfig_TimespanConfig.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_StorageConfig_TimespanConfig proto.InternalMessageInfo |
| |
| func (m *StorageConfig_TimespanConfig) GetStartTime() *timestamp.Timestamp { |
| if m != nil { |
| return m.StartTime |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig_TimespanConfig) GetEndTime() *timestamp.Timestamp { |
| if m != nil { |
| return m.EndTime |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig_TimespanConfig) GetTimestampField() *FieldId { |
| if m != nil { |
| return m.TimestampField |
| } |
| return nil |
| } |
| |
| func (m *StorageConfig_TimespanConfig) GetEnableAutoPopulationOfTimespanConfig() bool { |
| if m != nil { |
| return m.EnableAutoPopulationOfTimespanConfig |
| } |
| return false |
| } |
| |
| // Row key for identifying a record in BigQuery table. |
| type BigQueryKey struct { |
| // Complete BigQuery table reference. |
| TableReference *BigQueryTable `protobuf:"bytes,1,opt,name=table_reference,json=tableReference,proto3" json:"table_reference,omitempty"` |
| // Absolute number of the row from the beginning of the table at the time |
| // of scanning. |
| RowNumber int64 `protobuf:"varint,2,opt,name=row_number,json=rowNumber,proto3" json:"row_number,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BigQueryKey) Reset() { *m = BigQueryKey{} } |
| func (m *BigQueryKey) String() string { return proto.CompactTextString(m) } |
| func (*BigQueryKey) ProtoMessage() {} |
| func (*BigQueryKey) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{12} |
| } |
| func (m *BigQueryKey) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BigQueryKey.Unmarshal(m, b) |
| } |
| func (m *BigQueryKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BigQueryKey.Marshal(b, m, deterministic) |
| } |
| func (dst *BigQueryKey) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BigQueryKey.Merge(dst, src) |
| } |
| func (m *BigQueryKey) XXX_Size() int { |
| return xxx_messageInfo_BigQueryKey.Size(m) |
| } |
| func (m *BigQueryKey) XXX_DiscardUnknown() { |
| xxx_messageInfo_BigQueryKey.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BigQueryKey proto.InternalMessageInfo |
| |
| func (m *BigQueryKey) GetTableReference() *BigQueryTable { |
| if m != nil { |
| return m.TableReference |
| } |
| return nil |
| } |
| |
| func (m *BigQueryKey) GetRowNumber() int64 { |
| if m != nil { |
| return m.RowNumber |
| } |
| return 0 |
| } |
| |
| // Record key for a finding in Cloud Datastore. |
| type DatastoreKey struct { |
| // Datastore entity key. |
| EntityKey *Key `protobuf:"bytes,1,opt,name=entity_key,json=entityKey,proto3" json:"entity_key,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *DatastoreKey) Reset() { *m = DatastoreKey{} } |
| func (m *DatastoreKey) String() string { return proto.CompactTextString(m) } |
| func (*DatastoreKey) ProtoMessage() {} |
| func (*DatastoreKey) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{13} |
| } |
| func (m *DatastoreKey) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_DatastoreKey.Unmarshal(m, b) |
| } |
| func (m *DatastoreKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_DatastoreKey.Marshal(b, m, deterministic) |
| } |
| func (dst *DatastoreKey) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DatastoreKey.Merge(dst, src) |
| } |
| func (m *DatastoreKey) XXX_Size() int { |
| return xxx_messageInfo_DatastoreKey.Size(m) |
| } |
| func (m *DatastoreKey) XXX_DiscardUnknown() { |
| xxx_messageInfo_DatastoreKey.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DatastoreKey proto.InternalMessageInfo |
| |
| func (m *DatastoreKey) GetEntityKey() *Key { |
| if m != nil { |
| return m.EntityKey |
| } |
| return nil |
| } |
| |
| // A unique identifier for a Datastore entity. |
| // If a key's partition ID or any of its path kinds or names are |
| // reserved/read-only, the key is reserved/read-only. |
| // A reserved/read-only key is forbidden in certain documented contexts. |
| type Key struct { |
| // Entities are partitioned into subsets, currently identified by a project |
| // ID and namespace ID. |
| // Queries are scoped to a single partition. |
| PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"` |
| // The entity path. |
| // An entity path consists of one or more elements composed of a kind and a |
| // string or numerical identifier, which identify entities. The first |
| // element identifies a _root entity_, the second element identifies |
| // a _child_ of the root entity, the third element identifies a child of the |
| // second entity, and so forth. The entities identified by all prefixes of |
| // the path are called the element's _ancestors_. |
| // |
| // A path can never be empty, and a path can have at most 100 elements. |
| Path []*Key_PathElement `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Key) Reset() { *m = Key{} } |
| func (m *Key) String() string { return proto.CompactTextString(m) } |
| func (*Key) ProtoMessage() {} |
| func (*Key) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{14} |
| } |
| func (m *Key) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Key.Unmarshal(m, b) |
| } |
| func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Key.Marshal(b, m, deterministic) |
| } |
| func (dst *Key) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Key.Merge(dst, src) |
| } |
| func (m *Key) XXX_Size() int { |
| return xxx_messageInfo_Key.Size(m) |
| } |
| func (m *Key) XXX_DiscardUnknown() { |
| xxx_messageInfo_Key.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Key proto.InternalMessageInfo |
| |
| func (m *Key) GetPartitionId() *PartitionId { |
| if m != nil { |
| return m.PartitionId |
| } |
| return nil |
| } |
| |
| func (m *Key) GetPath() []*Key_PathElement { |
| if m != nil { |
| return m.Path |
| } |
| return nil |
| } |
| |
| // A (kind, ID/name) pair used to construct a key path. |
| // |
| // If either name or ID is set, the element is complete. |
| // If neither is set, the element is incomplete. |
| type Key_PathElement struct { |
| // The kind of the entity. |
| // A kind matching regex `__.*__` is reserved/read-only. |
| // A kind must not contain more than 1500 bytes when UTF-8 encoded. |
| // Cannot be `""`. |
| Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"` |
| // The type of ID. |
| // |
| // Types that are valid to be assigned to IdType: |
| // *Key_PathElement_Id |
| // *Key_PathElement_Name |
| IdType isKey_PathElement_IdType `protobuf_oneof:"id_type"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Key_PathElement) Reset() { *m = Key_PathElement{} } |
| func (m *Key_PathElement) String() string { return proto.CompactTextString(m) } |
| func (*Key_PathElement) ProtoMessage() {} |
| func (*Key_PathElement) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{14, 0} |
| } |
| func (m *Key_PathElement) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Key_PathElement.Unmarshal(m, b) |
| } |
| func (m *Key_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Key_PathElement.Marshal(b, m, deterministic) |
| } |
| func (dst *Key_PathElement) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Key_PathElement.Merge(dst, src) |
| } |
| func (m *Key_PathElement) XXX_Size() int { |
| return xxx_messageInfo_Key_PathElement.Size(m) |
| } |
| func (m *Key_PathElement) XXX_DiscardUnknown() { |
| xxx_messageInfo_Key_PathElement.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Key_PathElement proto.InternalMessageInfo |
| |
| func (m *Key_PathElement) GetKind() string { |
| if m != nil { |
| return m.Kind |
| } |
| return "" |
| } |
| |
| type isKey_PathElement_IdType interface { |
| isKey_PathElement_IdType() |
| } |
| |
| type Key_PathElement_Id struct { |
| Id int64 `protobuf:"varint,2,opt,name=id,proto3,oneof"` |
| } |
| |
| type Key_PathElement_Name struct { |
| Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof"` |
| } |
| |
| func (*Key_PathElement_Id) isKey_PathElement_IdType() {} |
| |
| func (*Key_PathElement_Name) isKey_PathElement_IdType() {} |
| |
| func (m *Key_PathElement) GetIdType() isKey_PathElement_IdType { |
| if m != nil { |
| return m.IdType |
| } |
| return nil |
| } |
| |
| func (m *Key_PathElement) GetId() int64 { |
| if x, ok := m.GetIdType().(*Key_PathElement_Id); ok { |
| return x.Id |
| } |
| return 0 |
| } |
| |
| func (m *Key_PathElement) GetName() string { |
| if x, ok := m.GetIdType().(*Key_PathElement_Name); ok { |
| return x.Name |
| } |
| return "" |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*Key_PathElement) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _Key_PathElement_OneofMarshaler, _Key_PathElement_OneofUnmarshaler, _Key_PathElement_OneofSizer, []interface{}{ |
| (*Key_PathElement_Id)(nil), |
| (*Key_PathElement_Name)(nil), |
| } |
| } |
| |
| func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*Key_PathElement) |
| // id_type |
| switch x := m.IdType.(type) { |
| case *Key_PathElement_Id: |
| b.EncodeVarint(2<<3 | proto.WireVarint) |
| b.EncodeVarint(uint64(x.Id)) |
| case *Key_PathElement_Name: |
| b.EncodeVarint(3<<3 | proto.WireBytes) |
| b.EncodeStringBytes(x.Name) |
| case nil: |
| default: |
| return fmt.Errorf("Key_PathElement.IdType has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _Key_PathElement_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*Key_PathElement) |
| switch tag { |
| case 2: // id_type.id |
| if wire != proto.WireVarint { |
| return true, proto.ErrInternalBadWireType |
| } |
| x, err := b.DecodeVarint() |
| m.IdType = &Key_PathElement_Id{int64(x)} |
| return true, err |
| case 3: // id_type.name |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| x, err := b.DecodeStringBytes() |
| m.IdType = &Key_PathElement_Name{x} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _Key_PathElement_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*Key_PathElement) |
| // id_type |
| switch x := m.IdType.(type) { |
| case *Key_PathElement_Id: |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(x.Id)) |
| case *Key_PathElement_Name: |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(len(x.Name))) |
| n += len(x.Name) |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Message for a unique key indicating a record that contains a finding. |
| type RecordKey struct { |
| // Types that are valid to be assigned to Type: |
| // *RecordKey_DatastoreKey |
| // *RecordKey_BigQueryKey |
| Type isRecordKey_Type `protobuf_oneof:"type"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RecordKey) Reset() { *m = RecordKey{} } |
| func (m *RecordKey) String() string { return proto.CompactTextString(m) } |
| func (*RecordKey) ProtoMessage() {} |
| func (*RecordKey) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{15} |
| } |
| func (m *RecordKey) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RecordKey.Unmarshal(m, b) |
| } |
| func (m *RecordKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RecordKey.Marshal(b, m, deterministic) |
| } |
| func (dst *RecordKey) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RecordKey.Merge(dst, src) |
| } |
| func (m *RecordKey) XXX_Size() int { |
| return xxx_messageInfo_RecordKey.Size(m) |
| } |
| func (m *RecordKey) XXX_DiscardUnknown() { |
| xxx_messageInfo_RecordKey.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RecordKey proto.InternalMessageInfo |
| |
| type isRecordKey_Type interface { |
| isRecordKey_Type() |
| } |
| |
| type RecordKey_DatastoreKey struct { |
| DatastoreKey *DatastoreKey `protobuf:"bytes,2,opt,name=datastore_key,json=datastoreKey,proto3,oneof"` |
| } |
| |
| type RecordKey_BigQueryKey struct { |
| BigQueryKey *BigQueryKey `protobuf:"bytes,3,opt,name=big_query_key,json=bigQueryKey,proto3,oneof"` |
| } |
| |
| func (*RecordKey_DatastoreKey) isRecordKey_Type() {} |
| |
| func (*RecordKey_BigQueryKey) isRecordKey_Type() {} |
| |
| func (m *RecordKey) GetType() isRecordKey_Type { |
| if m != nil { |
| return m.Type |
| } |
| return nil |
| } |
| |
| func (m *RecordKey) GetDatastoreKey() *DatastoreKey { |
| if x, ok := m.GetType().(*RecordKey_DatastoreKey); ok { |
| return x.DatastoreKey |
| } |
| return nil |
| } |
| |
| func (m *RecordKey) GetBigQueryKey() *BigQueryKey { |
| if x, ok := m.GetType().(*RecordKey_BigQueryKey); ok { |
| return x.BigQueryKey |
| } |
| return nil |
| } |
| |
| // XXX_OneofFuncs is for the internal use of the proto package. |
| func (*RecordKey) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { |
| return _RecordKey_OneofMarshaler, _RecordKey_OneofUnmarshaler, _RecordKey_OneofSizer, []interface{}{ |
| (*RecordKey_DatastoreKey)(nil), |
| (*RecordKey_BigQueryKey)(nil), |
| } |
| } |
| |
| func _RecordKey_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { |
| m := msg.(*RecordKey) |
| // type |
| switch x := m.Type.(type) { |
| case *RecordKey_DatastoreKey: |
| b.EncodeVarint(2<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.DatastoreKey); err != nil { |
| return err |
| } |
| case *RecordKey_BigQueryKey: |
| b.EncodeVarint(3<<3 | proto.WireBytes) |
| if err := b.EncodeMessage(x.BigQueryKey); err != nil { |
| return err |
| } |
| case nil: |
| default: |
| return fmt.Errorf("RecordKey.Type has unexpected type %T", x) |
| } |
| return nil |
| } |
| |
| func _RecordKey_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { |
| m := msg.(*RecordKey) |
| switch tag { |
| case 2: // type.datastore_key |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(DatastoreKey) |
| err := b.DecodeMessage(msg) |
| m.Type = &RecordKey_DatastoreKey{msg} |
| return true, err |
| case 3: // type.big_query_key |
| if wire != proto.WireBytes { |
| return true, proto.ErrInternalBadWireType |
| } |
| msg := new(BigQueryKey) |
| err := b.DecodeMessage(msg) |
| m.Type = &RecordKey_BigQueryKey{msg} |
| return true, err |
| default: |
| return false, nil |
| } |
| } |
| |
| func _RecordKey_OneofSizer(msg proto.Message) (n int) { |
| m := msg.(*RecordKey) |
| // type |
| switch x := m.Type.(type) { |
| case *RecordKey_DatastoreKey: |
| s := proto.Size(x.DatastoreKey) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case *RecordKey_BigQueryKey: |
| s := proto.Size(x.BigQueryKey) |
| n += 1 // tag and wire |
| n += proto.SizeVarint(uint64(s)) |
| n += s |
| case nil: |
| default: |
| panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) |
| } |
| return n |
| } |
| |
| // Message defining the location of a BigQuery table. A table is uniquely |
| // identified by its project_id, dataset_id, and table_name. Within a query |
| // a table is often referenced with a string in the format of: |
| // `<project_id>:<dataset_id>.<table_id>` or |
| // `<project_id>.<dataset_id>.<table_id>`. |
| type BigQueryTable struct { |
| // The Google Cloud Platform project ID of the project containing the table. |
| // If omitted, project ID is inferred from the API call. |
| ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"` |
| // Dataset ID of the table. |
| DatasetId string `protobuf:"bytes,2,opt,name=dataset_id,json=datasetId,proto3" json:"dataset_id,omitempty"` |
| // Name of the table. |
| TableId string `protobuf:"bytes,3,opt,name=table_id,json=tableId,proto3" json:"table_id,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BigQueryTable) Reset() { *m = BigQueryTable{} } |
| func (m *BigQueryTable) String() string { return proto.CompactTextString(m) } |
| func (*BigQueryTable) ProtoMessage() {} |
| func (*BigQueryTable) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{16} |
| } |
| func (m *BigQueryTable) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BigQueryTable.Unmarshal(m, b) |
| } |
| func (m *BigQueryTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BigQueryTable.Marshal(b, m, deterministic) |
| } |
| func (dst *BigQueryTable) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BigQueryTable.Merge(dst, src) |
| } |
| func (m *BigQueryTable) XXX_Size() int { |
| return xxx_messageInfo_BigQueryTable.Size(m) |
| } |
| func (m *BigQueryTable) XXX_DiscardUnknown() { |
| xxx_messageInfo_BigQueryTable.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BigQueryTable proto.InternalMessageInfo |
| |
| func (m *BigQueryTable) GetProjectId() string { |
| if m != nil { |
| return m.ProjectId |
| } |
| return "" |
| } |
| |
| func (m *BigQueryTable) GetDatasetId() string { |
| if m != nil { |
| return m.DatasetId |
| } |
| return "" |
| } |
| |
| func (m *BigQueryTable) GetTableId() string { |
| if m != nil { |
| return m.TableId |
| } |
| return "" |
| } |
| |
| // Message defining a field of a BigQuery table. |
| type BigQueryField struct { |
| // Source table of the field. |
| Table *BigQueryTable `protobuf:"bytes,1,opt,name=table,proto3" json:"table,omitempty"` |
| // Designated field in the BigQuery table. |
| Field *FieldId `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *BigQueryField) Reset() { *m = BigQueryField{} } |
| func (m *BigQueryField) String() string { return proto.CompactTextString(m) } |
| func (*BigQueryField) ProtoMessage() {} |
| func (*BigQueryField) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{17} |
| } |
| func (m *BigQueryField) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_BigQueryField.Unmarshal(m, b) |
| } |
| func (m *BigQueryField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_BigQueryField.Marshal(b, m, deterministic) |
| } |
| func (dst *BigQueryField) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_BigQueryField.Merge(dst, src) |
| } |
| func (m *BigQueryField) XXX_Size() int { |
| return xxx_messageInfo_BigQueryField.Size(m) |
| } |
| func (m *BigQueryField) XXX_DiscardUnknown() { |
| xxx_messageInfo_BigQueryField.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_BigQueryField proto.InternalMessageInfo |
| |
| func (m *BigQueryField) GetTable() *BigQueryTable { |
| if m != nil { |
| return m.Table |
| } |
| return nil |
| } |
| |
| func (m *BigQueryField) GetField() *FieldId { |
| if m != nil { |
| return m.Field |
| } |
| return nil |
| } |
| |
| // An entity in a dataset is a field or set of fields that correspond to a |
| // single person. For example, in medical records the `EntityId` might be a |
| // patient identifier, or for financial records it might be an account |
| // identifier. This message is used when generalizations or analysis must take |
| // into account that multiple rows correspond to the same entity. |
| type EntityId struct { |
| // Composite key indicating which field contains the entity identifier. |
| Field *FieldId `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *EntityId) Reset() { *m = EntityId{} } |
| func (m *EntityId) String() string { return proto.CompactTextString(m) } |
| func (*EntityId) ProtoMessage() {} |
| func (*EntityId) Descriptor() ([]byte, []int) { |
| return fileDescriptor_storage_3d89ec9d842babd2, []int{18} |
| } |
| func (m *EntityId) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_EntityId.Unmarshal(m, b) |
| } |
| func (m *EntityId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_EntityId.Marshal(b, m, deterministic) |
| } |
| func (dst *EntityId) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_EntityId.Merge(dst, src) |
| } |
| func (m *EntityId) XXX_Size() int { |
| return xxx_messageInfo_EntityId.Size(m) |
| } |
| func (m *EntityId) XXX_DiscardUnknown() { |
| xxx_messageInfo_EntityId.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_EntityId proto.InternalMessageInfo |
| |
| func (m *EntityId) GetField() *FieldId { |
| if m != nil { |
| return m.Field |
| } |
| return nil |
| } |
| |
| func init() { |
| proto.RegisterType((*InfoType)(nil), "google.privacy.dlp.v2.InfoType") |
| proto.RegisterType((*StoredType)(nil), "google.privacy.dlp.v2.StoredType") |
| proto.RegisterType((*CustomInfoType)(nil), "google.privacy.dlp.v2.CustomInfoType") |
| proto.RegisterType((*CustomInfoType_Dictionary)(nil), "google.privacy.dlp.v2.CustomInfoType.Dictionary") |
| proto.RegisterType((*CustomInfoType_Dictionary_WordList)(nil), "google.privacy.dlp.v2.CustomInfoType.Dictionary.WordList") |
| proto.RegisterType((*CustomInfoType_Regex)(nil), "google.privacy.dlp.v2.CustomInfoType.Regex") |
| proto.RegisterType((*CustomInfoType_SurrogateType)(nil), "google.privacy.dlp.v2.CustomInfoType.SurrogateType") |
| proto.RegisterType((*CustomInfoType_DetectionRule)(nil), "google.privacy.dlp.v2.CustomInfoType.DetectionRule") |
| proto.RegisterType((*CustomInfoType_DetectionRule_Proximity)(nil), "google.privacy.dlp.v2.CustomInfoType.DetectionRule.Proximity") |
| proto.RegisterType((*CustomInfoType_DetectionRule_LikelihoodAdjustment)(nil), "google.privacy.dlp.v2.CustomInfoType.DetectionRule.LikelihoodAdjustment") |
| proto.RegisterType((*CustomInfoType_DetectionRule_HotwordRule)(nil), "google.privacy.dlp.v2.CustomInfoType.DetectionRule.HotwordRule") |
| proto.RegisterType((*FieldId)(nil), "google.privacy.dlp.v2.FieldId") |
| proto.RegisterType((*PartitionId)(nil), "google.privacy.dlp.v2.PartitionId") |
| proto.RegisterType((*KindExpression)(nil), "google.privacy.dlp.v2.KindExpression") |
| proto.RegisterType((*DatastoreOptions)(nil), "google.privacy.dlp.v2.DatastoreOptions") |
| proto.RegisterType((*CloudStorageOptions)(nil), "google.privacy.dlp.v2.CloudStorageOptions") |
| proto.RegisterType((*CloudStorageOptions_FileSet)(nil), "google.privacy.dlp.v2.CloudStorageOptions.FileSet") |
| proto.RegisterType((*CloudStorageFileSet)(nil), "google.privacy.dlp.v2.CloudStorageFileSet") |
| proto.RegisterType((*CloudStoragePath)(nil), "google.privacy.dlp.v2.CloudStoragePath") |
| proto.RegisterType((*BigQueryOptions)(nil), "google.privacy.dlp.v2.BigQueryOptions") |
| proto.RegisterType((*StorageConfig)(nil), "google.privacy.dlp.v2.StorageConfig") |
| proto.RegisterType((*StorageConfig_TimespanConfig)(nil), "google.privacy.dlp.v2.StorageConfig.TimespanConfig") |
| proto.RegisterType((*BigQueryKey)(nil), "google.privacy.dlp.v2.BigQueryKey") |
| proto.RegisterType((*DatastoreKey)(nil), "google.privacy.dlp.v2.DatastoreKey") |
| proto.RegisterType((*Key)(nil), "google.privacy.dlp.v2.Key") |
| proto.RegisterType((*Key_PathElement)(nil), "google.privacy.dlp.v2.Key.PathElement") |
| proto.RegisterType((*RecordKey)(nil), "google.privacy.dlp.v2.RecordKey") |
| proto.RegisterType((*BigQueryTable)(nil), "google.privacy.dlp.v2.BigQueryTable") |
| proto.RegisterType((*BigQueryField)(nil), "google.privacy.dlp.v2.BigQueryField") |
| proto.RegisterType((*EntityId)(nil), "google.privacy.dlp.v2.EntityId") |
| proto.RegisterEnum("google.privacy.dlp.v2.Likelihood", Likelihood_name, Likelihood_value) |
| proto.RegisterEnum("google.privacy.dlp.v2.FileType", FileType_name, FileType_value) |
| proto.RegisterEnum("google.privacy.dlp.v2.CloudStorageOptions_SampleMethod", CloudStorageOptions_SampleMethod_name, CloudStorageOptions_SampleMethod_value) |
| proto.RegisterEnum("google.privacy.dlp.v2.BigQueryOptions_SampleMethod", BigQueryOptions_SampleMethod_name, BigQueryOptions_SampleMethod_value) |
| } |
| |
| func init() { |
| proto.RegisterFile("google/privacy/dlp/v2/storage.proto", fileDescriptor_storage_3d89ec9d842babd2) |
| } |
| |
| var fileDescriptor_storage_3d89ec9d842babd2 = []byte{ |
| // 1865 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xdd, 0x72, 0x1b, 0x49, |
| 0x15, 0xd6, 0x48, 0x96, 0x25, 0x1d, 0xfd, 0x58, 0x6e, 0x3b, 0x94, 0x22, 0x36, 0xbb, 0x8e, 0x12, |
| 0xb2, 0x26, 0x50, 0x12, 0x38, 0x50, 0x90, 0x5d, 0x58, 0xb0, 0x22, 0x65, 0x25, 0xfc, 0x27, 0x5a, |
| 0xda, 0xfc, 0x80, 0xa9, 0x61, 0xa4, 0x69, 0xc9, 0xbd, 0x19, 0x4d, 0x0f, 0x33, 0xad, 0x38, 0x2a, |
| 0x8a, 0x0b, 0x6e, 0xb9, 0xe1, 0x02, 0x1e, 0x80, 0x0b, 0xaa, 0x28, 0x28, 0x9e, 0x00, 0xde, 0x80, |
| 0x87, 0xe0, 0x05, 0x78, 0x09, 0xaa, 0xbb, 0xe7, 0x4f, 0x8a, 0xb5, 0x96, 0x53, 0xb9, 0xd2, 0xf4, |
| 0xe9, 0xf3, 0x9d, 0xd3, 0xe7, 0xb7, 0x4f, 0x0b, 0xee, 0x4d, 0x18, 0x9b, 0x58, 0xa4, 0xe1, 0xb8, |
| 0xf4, 0xb5, 0x31, 0x9a, 0x37, 0x4c, 0xcb, 0x69, 0xbc, 0x3e, 0x68, 0x78, 0x9c, 0xb9, 0xc6, 0x84, |
| 0xd4, 0x1d, 0x97, 0x71, 0x86, 0x6e, 0x29, 0xa6, 0xba, 0xcf, 0x54, 0x37, 0x2d, 0xa7, 0xfe, 0xfa, |
| 0xa0, 0xfa, 0x81, 0x8f, 0x35, 0x1c, 0xda, 0x30, 0x6c, 0x9b, 0x71, 0x83, 0x53, 0x66, 0x7b, 0x0a, |
| 0x54, 0xfd, 0x28, 0x94, 0xcc, 0x38, 0x1b, 0xce, 0xc6, 0x0d, 0x4e, 0xa7, 0xc4, 0xe3, 0xc6, 0xd4, |
| 0x51, 0x0c, 0xb5, 0x0f, 0x21, 0xdb, 0xb5, 0xc7, 0x6c, 0x30, 0x77, 0x08, 0x42, 0xb0, 0x61, 0x1b, |
| 0x53, 0x52, 0xd1, 0xf6, 0xb4, 0xfd, 0x1c, 0x96, 0xdf, 0xb5, 0x5f, 0x01, 0xf4, 0x39, 0x73, 0x89, |
| 0xb9, 0x8a, 0x03, 0x7d, 0x0a, 0xf9, 0x91, 0x4b, 0x0c, 0x4e, 0x74, 0x21, 0xbb, 0x92, 0xdc, 0xd3, |
| 0xf6, 0xf3, 0x07, 0xd5, 0x7a, 0x78, 0x5a, 0xa5, 0xb8, 0x3e, 0x08, 0x14, 0x63, 0x50, 0xec, 0x82, |
| 0x50, 0xfb, 0x53, 0x01, 0x4a, 0x4f, 0x66, 0x1e, 0x67, 0xd3, 0xf0, 0x14, 0x3f, 0x82, 0x1c, 0xb5, |
| 0xc7, 0x4c, 0xe7, 0x73, 0x47, 0x29, 0xca, 0x1f, 0x7c, 0x54, 0xbf, 0xd2, 0xf6, 0x7a, 0x80, 0xc1, |
| 0x59, 0x1a, 0xa0, 0x0f, 0x01, 0x2c, 0xfa, 0x8a, 0x58, 0xf4, 0x82, 0x31, 0xb3, 0xb2, 0xb9, 0xa7, |
| 0xed, 0x97, 0x0e, 0xee, 0xae, 0x80, 0x1f, 0x87, 0x8c, 0x38, 0x06, 0x42, 0x18, 0xc0, 0xa4, 0x23, |
| 0xe1, 0x45, 0xc3, 0x9d, 0xfb, 0xf6, 0x7c, 0x67, 0x85, 0x88, 0xc5, 0xb3, 0xd7, 0x5b, 0x21, 0xae, |
| 0x93, 0xc0, 0x31, 0x29, 0xe8, 0x09, 0xa4, 0x5d, 0x32, 0x21, 0x6f, 0x2a, 0x29, 0x29, 0xee, 0x5b, |
| 0xeb, 0x89, 0xc3, 0x02, 0xd2, 0x49, 0x60, 0x85, 0x45, 0xe7, 0x50, 0xf2, 0x66, 0xae, 0xcb, 0x26, |
| 0xd2, 0xd9, 0xc2, 0x3d, 0x1b, 0x52, 0xda, 0xa3, 0xf5, 0xa4, 0xf5, 0x03, 0xac, 0x58, 0x75, 0x12, |
| 0xb8, 0xe8, 0xc5, 0x09, 0xa8, 0x05, 0x79, 0x4f, 0x46, 0x5a, 0x89, 0x4e, 0x4b, 0xd1, 0xab, 0x5c, |
| 0x17, 0xe5, 0x84, 0x30, 0xd4, 0x8b, 0x32, 0xe4, 0x1c, 0xb6, 0x4c, 0xc2, 0x89, 0x34, 0x5c, 0x77, |
| 0x67, 0x16, 0xf1, 0x2a, 0x99, 0xbd, 0xd4, 0xfa, 0x87, 0x6c, 0x05, 0x60, 0x3c, 0xb3, 0x08, 0x2e, |
| 0x99, 0xf1, 0xa5, 0x57, 0xfd, 0x9f, 0x06, 0x10, 0xf9, 0x18, 0xbd, 0x80, 0xdc, 0x25, 0x73, 0x4d, |
| 0xdd, 0xa2, 0x1e, 0xf7, 0x53, 0xe5, 0xf1, 0x4d, 0x03, 0x55, 0x7f, 0xce, 0x5c, 0xf3, 0x98, 0x7a, |
| 0xbc, 0x93, 0xc0, 0xd9, 0x4b, 0xff, 0x1b, 0x3d, 0x07, 0x34, 0xb2, 0xd8, 0xcc, 0xd4, 0xfd, 0x1a, |
| 0xd4, 0x1d, 0x83, 0x5f, 0xf8, 0xc1, 0xfb, 0x78, 0x95, 0x0a, 0x01, 0xe8, 0x2b, 0xfe, 0x9e, 0xc1, |
| 0x2f, 0x3a, 0x09, 0x5c, 0x1e, 0x2d, 0xd1, 0xaa, 0x7b, 0x90, 0x0d, 0x14, 0xa2, 0x5d, 0x48, 0x0b, |
| 0x85, 0x5e, 0x45, 0xdb, 0x4b, 0xed, 0xe7, 0xb0, 0x5a, 0x34, 0xb3, 0xb0, 0xe9, 0xb1, 0x99, 0x3b, |
| 0x22, 0xd5, 0xbb, 0x90, 0x96, 0x19, 0x80, 0x2a, 0x90, 0x71, 0x0c, 0xce, 0x89, 0x6b, 0xfb, 0x95, |
| 0x17, 0x2c, 0xab, 0x5b, 0x50, 0x5c, 0x08, 0x6b, 0xf5, 0x5f, 0x69, 0x28, 0x2e, 0xf8, 0x10, 0x99, |
| 0x50, 0xb8, 0x60, 0x5c, 0xfa, 0x49, 0xc4, 0xc3, 0xf7, 0xd3, 0x4f, 0xde, 0x21, 0x1c, 0xf5, 0x8e, |
| 0x92, 0x23, 0xbe, 0x3b, 0x09, 0x9c, 0xbf, 0x88, 0x96, 0xd5, 0x3e, 0xe4, 0x7a, 0x2e, 0x7b, 0x43, |
| 0xa7, 0x94, 0xcf, 0xd1, 0x3d, 0x28, 0x5e, 0x52, 0xdb, 0x64, 0x97, 0xfa, 0x90, 0x8c, 0x99, 0xab, |
| 0x74, 0xa6, 0x71, 0x41, 0x11, 0x9b, 0x92, 0x86, 0xee, 0x82, 0xbf, 0xd6, 0x8d, 0x31, 0x27, 0xae, |
| 0x2c, 0xb4, 0x34, 0xce, 0x2b, 0xda, 0xa1, 0x20, 0x55, 0xff, 0xa6, 0xc1, 0x6e, 0x54, 0xa4, 0x87, |
| 0xe6, 0x97, 0x33, 0x8f, 0x4f, 0x89, 0xcd, 0xd1, 0x29, 0x94, 0xc7, 0xf4, 0x0d, 0x11, 0x91, 0x0f, |
| 0x6b, 0x5d, 0x5b, 0xb3, 0xd6, 0x3b, 0x09, 0xbc, 0x25, 0xc1, 0x11, 0x09, 0x7d, 0x17, 0x76, 0x5c, |
| 0x62, 0x19, 0x9c, 0xbe, 0x26, 0x71, 0x91, 0xf2, 0x48, 0x9d, 0x04, 0x46, 0xc1, 0x66, 0x04, 0x69, |
| 0x16, 0x00, 0x8c, 0xf0, 0x40, 0xd5, 0x7f, 0x27, 0x21, 0x1f, 0xf3, 0x0e, 0xea, 0x41, 0x31, 0x74, |
| 0xba, 0xac, 0x7b, 0xed, 0xc6, 0x75, 0x8f, 0x83, 0xb0, 0xa9, 0x1c, 0xf8, 0x25, 0xe4, 0x9c, 0xc0, |
| 0xc1, 0x7e, 0x53, 0xfa, 0xf1, 0xbb, 0xc4, 0x30, 0x8c, 0x12, 0x8e, 0xe4, 0xa1, 0xdf, 0xc1, 0xad, |
| 0xc8, 0x6c, 0x3d, 0xb2, 0xcb, 0xcf, 0xf8, 0xce, 0xbb, 0x28, 0xba, 0x2a, 0x70, 0x78, 0xd7, 0xba, |
| 0x82, 0xda, 0xdc, 0x84, 0x0d, 0xd1, 0x73, 0x82, 0xdf, 0xda, 0x1d, 0xc8, 0x3c, 0xa5, 0xc4, 0x32, |
| 0xbb, 0xe6, 0x95, 0x77, 0xd2, 0x19, 0xe4, 0x7b, 0x86, 0xcb, 0xa9, 0x50, 0xd5, 0x35, 0xd1, 0x1d, |
| 0x00, 0xc7, 0x65, 0x5f, 0x92, 0x11, 0xd7, 0xa9, 0x8a, 0x59, 0x4e, 0xda, 0x26, 0x28, 0x5d, 0x53, |
| 0xe4, 0x99, 0x40, 0x79, 0x8e, 0x31, 0x22, 0x82, 0x61, 0x43, 0x32, 0xe4, 0x43, 0x5a, 0xd7, 0xac, |
| 0xdd, 0x87, 0xd2, 0x11, 0xb5, 0xcd, 0xf6, 0x1b, 0xc7, 0x25, 0x9e, 0x47, 0x99, 0x7d, 0xa5, 0xda, |
| 0x3f, 0x6b, 0x50, 0x6e, 0x19, 0xdc, 0x90, 0xdd, 0xee, 0xcc, 0x91, 0xd7, 0x2c, 0x6a, 0x43, 0xc1, |
| 0x09, 0xce, 0x22, 0xa4, 0xab, 0x38, 0xd7, 0x56, 0x38, 0x2c, 0x76, 0x6c, 0x9c, 0x77, 0x62, 0x36, |
| 0x3c, 0x86, 0x8d, 0x57, 0xd4, 0x36, 0xfd, 0xc0, 0x7e, 0x63, 0x05, 0x7c, 0xf1, 0x90, 0x58, 0x42, |
| 0x6a, 0x7f, 0xd8, 0x80, 0x9d, 0x78, 0xeb, 0x09, 0x4e, 0x76, 0x02, 0xd9, 0x31, 0xb5, 0x88, 0xee, |
| 0x91, 0xa0, 0x37, 0x1e, 0xac, 0xd1, 0xb8, 0x7c, 0x74, 0xfd, 0x29, 0xb5, 0x48, 0x9f, 0x70, 0x9c, |
| 0x19, 0xab, 0x0f, 0xd4, 0x80, 0xdd, 0xe1, 0x9c, 0x13, 0x4f, 0xb7, 0x44, 0xca, 0xe8, 0x0e, 0x71, |
| 0x75, 0xb1, 0x25, 0xdd, 0x99, 0xc2, 0xdb, 0x72, 0xef, 0x58, 0x6c, 0xf5, 0x88, 0x2b, 0xc0, 0xe8, |
| 0x33, 0xf8, 0xe0, 0x2a, 0x80, 0xf8, 0x18, 0x89, 0xd4, 0xca, 0xca, 0x7a, 0xaf, 0xbc, 0x05, 0xec, |
| 0xa9, 0x7d, 0xf4, 0x19, 0x80, 0xe4, 0x17, 0x19, 0xe1, 0x55, 0xd2, 0x7b, 0xa9, 0xfd, 0xd2, 0xca, |
| 0x41, 0x40, 0xe0, 0xe4, 0x20, 0x90, 0x1b, 0xfb, 0x5f, 0x1e, 0x3a, 0x87, 0xa2, 0x67, 0x4c, 0x1d, |
| 0x8b, 0xe8, 0x53, 0xc2, 0x2f, 0xc2, 0x61, 0xe0, 0x07, 0x37, 0x70, 0x42, 0x5f, 0xe2, 0x4f, 0x24, |
| 0x1c, 0x17, 0xbc, 0xd8, 0x0a, 0xd5, 0x61, 0x47, 0xa8, 0x8a, 0x59, 0x27, 0x8d, 0xca, 0x48, 0xa3, |
| 0xb6, 0xe5, 0x56, 0x60, 0x94, 0xd8, 0xa8, 0x7e, 0x5d, 0xa4, 0xb4, 0xf2, 0x64, 0x19, 0x52, 0x33, |
| 0xd7, 0xf2, 0x53, 0x4b, 0x7c, 0xd6, 0x3a, 0x50, 0x88, 0xab, 0x42, 0x77, 0xe0, 0x76, 0xff, 0xf0, |
| 0xa4, 0x77, 0xdc, 0xd6, 0x4f, 0xda, 0x83, 0xce, 0x59, 0x4b, 0xff, 0xe2, 0xb4, 0xdf, 0x6b, 0x3f, |
| 0xe9, 0x3e, 0xed, 0xb6, 0x5b, 0xe5, 0x04, 0xca, 0x40, 0x6a, 0x70, 0xd6, 0x2b, 0x6b, 0xa8, 0x0c, |
| 0x05, 0x7c, 0x78, 0xda, 0x3a, 0x3b, 0xd1, 0xfb, 0x83, 0x43, 0x3c, 0x28, 0x27, 0x6b, 0x1f, 0x2f, |
| 0xe6, 0xc2, 0x6a, 0x95, 0x0f, 0xa0, 0xbc, 0x7c, 0x5f, 0x89, 0xa4, 0x97, 0xd7, 0x9c, 0x9f, 0xf4, |
| 0xe2, 0xbb, 0xf6, 0x97, 0x14, 0x6c, 0x35, 0xe9, 0xe4, 0xe7, 0x33, 0xe2, 0xce, 0xa3, 0xcc, 0xda, |
| 0xe2, 0xc6, 0xd0, 0x22, 0xba, 0x4b, 0xc6, 0xc4, 0x25, 0xf6, 0x28, 0xb8, 0x54, 0xee, 0xaf, 0xf0, |
| 0x6d, 0x20, 0x60, 0x20, 0x50, 0xb8, 0x24, 0xc1, 0x38, 0xc0, 0xa2, 0x13, 0x40, 0xd4, 0x24, 0x36, |
| 0xa7, 0xe3, 0x39, 0xb5, 0x27, 0xfa, 0x58, 0x54, 0xbe, 0x57, 0x49, 0xca, 0xa9, 0xe1, 0xc3, 0x95, |
| 0x01, 0x97, 0xed, 0x01, 0x6f, 0xc7, 0x90, 0x92, 0xe6, 0x89, 0x76, 0xe0, 0xb2, 0x4b, 0x3f, 0x30, |
| 0xb2, 0x81, 0xa5, 0x70, 0x4e, 0x50, 0x64, 0x3c, 0xd0, 0xb7, 0x01, 0x45, 0xdb, 0x61, 0xdc, 0x36, |
| 0x65, 0xdc, 0xca, 0x21, 0x5b, 0x90, 0x84, 0x2f, 0x96, 0x93, 0x68, 0x43, 0x26, 0xd1, 0xa3, 0x6b, |
| 0x0c, 0xbd, 0x3e, 0x81, 0xde, 0x63, 0xcc, 0xff, 0x99, 0x86, 0xa2, 0x1f, 0xc6, 0x27, 0xcc, 0x1e, |
| 0xd3, 0x09, 0x7a, 0x06, 0xdb, 0x66, 0xd0, 0xa8, 0x74, 0xa6, 0xce, 0xe2, 0xb7, 0x96, 0x55, 0xc3, |
| 0xcb, 0x72, 0x63, 0x13, 0xc3, 0x8b, 0xb9, 0xdc, 0xec, 0x7e, 0x0d, 0xb7, 0x16, 0xa7, 0xa2, 0x40, |
| 0xb6, 0xba, 0x26, 0x1e, 0xae, 0x5f, 0x5a, 0x9d, 0x04, 0xde, 0x19, 0x5d, 0xd1, 0xb4, 0x06, 0xb0, |
| 0x3d, 0xa4, 0x13, 0xfd, 0x37, 0xc2, 0x89, 0xa1, 0x74, 0x35, 0xe5, 0x3e, 0x58, 0xcf, 0xe7, 0xe2, |
| 0x7a, 0x1f, 0x2e, 0x25, 0xec, 0x39, 0x6c, 0xc9, 0x77, 0x8f, 0x63, 0xd8, 0xfa, 0x48, 0xba, 0x48, |
| 0x06, 0x7c, 0xf5, 0x50, 0xba, 0xe0, 0x4e, 0xf5, 0x74, 0x71, 0x0c, 0x5b, 0x2d, 0x71, 0x89, 0x2f, |
| 0xac, 0xab, 0x7f, 0x4d, 0x42, 0x69, 0x91, 0x05, 0x3d, 0x06, 0xf0, 0xb8, 0xe1, 0x72, 0xf5, 0x24, |
| 0xd2, 0xae, 0x7d, 0x12, 0xe5, 0x24, 0xb7, 0x58, 0xa3, 0xef, 0x43, 0x96, 0xd8, 0xe6, 0xba, 0x6f, |
| 0xa9, 0x0c, 0xb1, 0x4d, 0x09, 0xfb, 0xdc, 0x37, 0x51, 0x50, 0x55, 0x09, 0xf9, 0x41, 0xb9, 0xae, |
| 0x82, 0x4a, 0x21, 0x4c, 0x52, 0xd0, 0x73, 0xf8, 0x26, 0xb1, 0x65, 0x75, 0x1b, 0x33, 0xce, 0x74, |
| 0x87, 0x39, 0x33, 0x4b, 0x3e, 0x29, 0x75, 0x36, 0xd6, 0x97, 0xbd, 0x28, 0x22, 0x93, 0xc5, 0xf7, |
| 0x15, 0xe0, 0x70, 0xc6, 0x59, 0x2f, 0x64, 0x3f, 0x1b, 0x2f, 0xfa, 0x24, 0xbc, 0xdc, 0x7f, 0x0b, |
| 0xf9, 0x20, 0x64, 0x47, 0x64, 0xfe, 0xbe, 0x9b, 0x89, 0xaa, 0x7e, 0xdd, 0x9e, 0x4d, 0x87, 0xfe, |
| 0x4c, 0xa9, 0xaa, 0xff, 0x54, 0x12, 0x6a, 0x5d, 0x28, 0x84, 0x99, 0x2e, 0xb4, 0x3f, 0x06, 0x10, |
| 0xfd, 0x83, 0xcf, 0xf5, 0x57, 0x64, 0xfe, 0x76, 0xa0, 0x16, 0x6f, 0x5f, 0x32, 0xc7, 0x39, 0xc5, |
| 0x7d, 0x44, 0xe6, 0xb5, 0xff, 0x6a, 0x90, 0x12, 0x22, 0xde, 0xd3, 0x04, 0xf0, 0x89, 0xdf, 0x7c, |
| 0x55, 0xdf, 0x7b, 0xb0, 0xfa, 0x0c, 0x75, 0xd1, 0xab, 0xdb, 0x16, 0x91, 0xf3, 0x94, 0xc4, 0x54, |
| 0x07, 0x62, 0x20, 0x0a, 0x89, 0xa2, 0x8f, 0xcb, 0x61, 0xc2, 0xef, 0xe3, 0xe2, 0x1b, 0x95, 0x21, |
| 0xe9, 0x0f, 0x47, 0xa9, 0x4e, 0x02, 0x27, 0xa9, 0x89, 0x76, 0xfd, 0x11, 0x47, 0xa4, 0x49, 0xae, |
| 0x93, 0x50, 0x43, 0x4e, 0x33, 0x07, 0x19, 0xaa, 0x5e, 0x80, 0xb5, 0xbf, 0x6b, 0x90, 0xc3, 0x64, |
| 0xc4, 0x5c, 0x53, 0x98, 0xf9, 0x33, 0x28, 0x46, 0x3d, 0x45, 0x38, 0x4b, 0x25, 0xe7, 0xbd, 0xeb, |
| 0xfa, 0xc9, 0x11, 0x11, 0x6f, 0xe1, 0x82, 0x19, 0xf7, 0x7a, 0x07, 0x8a, 0x51, 0x95, 0x0b, 0x59, |
| 0xa9, 0xaf, 0xf4, 0x59, 0x2c, 0x5d, 0xc4, 0xb3, 0x63, 0x18, 0x2d, 0xc3, 0xa4, 0xba, 0x80, 0xe2, |
| 0x42, 0x5e, 0x2c, 0x0d, 0x85, 0xda, 0xf2, 0x50, 0x78, 0x07, 0x40, 0x9e, 0x88, 0xc4, 0x67, 0x46, |
| 0x9f, 0xd2, 0x35, 0xd1, 0x6d, 0xc8, 0xaa, 0xa4, 0xa4, 0xaa, 0x8c, 0x72, 0x38, 0x23, 0xd7, 0x5d, |
| 0xb3, 0xf6, 0x7b, 0x2d, 0x52, 0xa5, 0x2a, 0xe6, 0x13, 0x48, 0xcb, 0xcd, 0x1b, 0xe5, 0xad, 0x82, |
| 0xa0, 0xef, 0x41, 0x5a, 0x15, 0x6b, 0x72, 0xad, 0x62, 0x55, 0xcc, 0xb5, 0x9f, 0x42, 0xb6, 0x2d, |
| 0xf3, 0xb0, 0x6b, 0x46, 0x12, 0xb4, 0x1b, 0x48, 0x78, 0xc8, 0x01, 0x62, 0xcf, 0x9f, 0x2a, 0x7c, |
| 0xed, 0xb8, 0x7b, 0xd4, 0x3e, 0xee, 0x76, 0xce, 0xde, 0xba, 0x78, 0xb6, 0xa1, 0xf8, 0xac, 0x8d, |
| 0x5f, 0xea, 0x5f, 0x9c, 0x4a, 0x96, 0x97, 0x65, 0x0d, 0x15, 0x20, 0x1b, 0xae, 0x92, 0x62, 0xd5, |
| 0x3b, 0xeb, 0xf7, 0xbb, 0xcd, 0xe3, 0x76, 0x39, 0x85, 0x00, 0x36, 0xfd, 0x9d, 0x0d, 0xb4, 0x05, |
| 0x79, 0x09, 0xf5, 0x09, 0xe9, 0x87, 0x6d, 0xc8, 0x06, 0x93, 0x1a, 0xba, 0x0d, 0xb7, 0x9e, 0x76, |
| 0x8f, 0xdb, 0xfa, 0xe0, 0x65, 0xaf, 0xbd, 0xa4, 0x72, 0x0b, 0xf2, 0xcd, 0xee, 0xe9, 0x21, 0x7e, |
| 0xa9, 0x0b, 0x8e, 0xb2, 0x86, 0x8a, 0x90, 0x1b, 0xb4, 0x5f, 0x0c, 0xd4, 0x32, 0xd9, 0xfc, 0xa3, |
| 0x06, 0xb7, 0x47, 0x6c, 0x7a, 0xb5, 0xa5, 0x4d, 0x68, 0x59, 0x4e, 0x30, 0xd5, 0x68, 0xbf, 0xf8, |
| 0xa1, 0xcf, 0x34, 0x61, 0x96, 0x61, 0x4f, 0xea, 0xcc, 0x9d, 0x34, 0x26, 0xc4, 0x96, 0x9d, 0xb4, |
| 0xa1, 0xb6, 0x0c, 0x87, 0x7a, 0x4b, 0xff, 0xbc, 0x7d, 0x6a, 0x5a, 0xce, 0x3f, 0x92, 0x3b, 0x9f, |
| 0x2b, 0xa8, 0xbc, 0xbe, 0xea, 0x2d, 0xcb, 0xa9, 0x3f, 0x3b, 0xf8, 0x4f, 0x40, 0x3d, 0x97, 0xd4, |
| 0xf3, 0x96, 0xe5, 0x9c, 0x3f, 0x3b, 0x18, 0x6e, 0x4a, 0x81, 0x8f, 0xfe, 0x1f, 0x00, 0x00, 0xff, |
| 0xff, 0x3a, 0x91, 0x84, 0x5f, 0xc9, 0x13, 0x00, 0x00, |
| } |