vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/storage.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/privacy/dlp/v2beta1/storage.proto
   3
   4 package dlp
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import _ "github.com/golang/protobuf/ptypes/timestamp"
  11
  12 // Reference imports to suppress errors if they are not otherwise used.
  13 var _ = proto.Marshal
  14 var _ = fmt.Errorf
  15 var _ = math.Inf
  16
  17 // Type of information detected by the API.
  18 type InfoType struct {
  19         // Name of the information type.
  20         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  21 }
  22
  23 func (m *InfoType) Reset()                    { *m = InfoType{} }
  24 func (m *InfoType) String() string            { return proto.CompactTextString(m) }
  25 func (*InfoType) ProtoMessage()               {}
  26 func (*InfoType) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  27
  28 func (m *InfoType) GetName() string {
  29         if m != nil {
  30                 return m.Name
  31         }
  32         return ""
  33 }
  34
  35 // General identifier of a data field in a storage service.
  36 type FieldId struct {
  37         // Name describing the field.
  38         ColumnName string `protobuf:"bytes,1,opt,name=column_name,json=columnName" json:"column_name,omitempty"`
  39 }
  40
  41 func (m *FieldId) Reset()                    { *m = FieldId{} }
  42 func (m *FieldId) String() string            { return proto.CompactTextString(m) }
  43 func (*FieldId) ProtoMessage()               {}
  44 func (*FieldId) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
  45
  46 func (m *FieldId) GetColumnName() string {
  47         if m != nil {
  48                 return m.ColumnName
  49         }
  50         return ""
  51 }
  52
  53 // Datastore partition ID.
  54 // A partition ID identifies a grouping of entities. The grouping is always
  55 // by project and namespace, however the namespace ID may be empty.
  56 //
  57 // A partition ID contains several dimensions:
  58 // project ID and namespace ID.
  59 type PartitionId struct {
  60         // The ID of the project to which the entities belong.
  61         ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
  62         // If not empty, the ID of the namespace to which the entities belong.
  63         NamespaceId string `protobuf:"bytes,4,opt,name=namespace_id,json=namespaceId" json:"namespace_id,omitempty"`
  64 }
  65
  66 func (m *PartitionId) Reset()                    { *m = PartitionId{} }
  67 func (m *PartitionId) String() string            { return proto.CompactTextString(m) }
  68 func (*PartitionId) ProtoMessage()               {}
  69 func (*PartitionId) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
  70
  71 func (m *PartitionId) GetProjectId() string {
  72         if m != nil {
  73                 return m.ProjectId
  74         }
  75         return ""
  76 }
  77
  78 func (m *PartitionId) GetNamespaceId() string {
  79         if m != nil {
  80                 return m.NamespaceId
  81         }
  82         return ""
  83 }
  84
  85 // A representation of a Datastore kind.
  86 type KindExpression struct {
  87         // The name of the kind.
  88         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  89 }
  90
  91 func (m *KindExpression) Reset()                    { *m = KindExpression{} }
  92 func (m *KindExpression) String() string            { return proto.CompactTextString(m) }
  93 func (*KindExpression) ProtoMessage()               {}
  94 func (*KindExpression) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
  95
  96 func (m *KindExpression) GetName() string {
  97         if m != nil {
  98                 return m.Name
  99         }
 100         return ""
 101 }
 102
 103 // A reference to a property relative to the Datastore kind expressions.
 104 type PropertyReference struct {
 105         // The name of the property.
 106         // If name includes "."s, it may be interpreted as a property name path.
 107         Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
 108 }
 109
 110 func (m *PropertyReference) Reset()                    { *m = PropertyReference{} }
 111 func (m *PropertyReference) String() string            { return proto.CompactTextString(m) }
 112 func (*PropertyReference) ProtoMessage()               {}
 113 func (*PropertyReference) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 114
 115 func (m *PropertyReference) GetName() string {
 116         if m != nil {
 117                 return m.Name
 118         }
 119         return ""
 120 }
 121
 122 // A representation of a Datastore property in a projection.
 123 type Projection struct {
 124         // The property to project.
 125         Property *PropertyReference `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
 126 }
 127
 128 func (m *Projection) Reset()                    { *m = Projection{} }
 129 func (m *Projection) String() string            { return proto.CompactTextString(m) }
 130 func (*Projection) ProtoMessage()               {}
 131 func (*Projection) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
 132
 133 func (m *Projection) GetProperty() *PropertyReference {
 134         if m != nil {
 135                 return m.Property
 136         }
 137         return nil
 138 }
 139
 140 // Options defining a data set within Google Cloud Datastore.
 141 type DatastoreOptions struct {
 142         // A partition ID identifies a grouping of entities. The grouping is always
 143         // by project and namespace, however the namespace ID may be empty.
 144         PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId" json:"partition_id,omitempty"`
 145         // The kind to process.
 146         Kind *KindExpression `protobuf:"bytes,2,opt,name=kind" json:"kind,omitempty"`
 147         // Properties to scan. If none are specified, all properties will be scanned
 148         // by default.
 149         Projection []*Projection `protobuf:"bytes,3,rep,name=projection" json:"projection,omitempty"`
 150 }
 151
 152 func (m *DatastoreOptions) Reset()                    { *m = DatastoreOptions{} }
 153 func (m *DatastoreOptions) String() string            { return proto.CompactTextString(m) }
 154 func (*DatastoreOptions) ProtoMessage()               {}
 155 func (*DatastoreOptions) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
 156
 157 func (m *DatastoreOptions) GetPartitionId() *PartitionId {
 158         if m != nil {
 159                 return m.PartitionId
 160         }
 161         return nil
 162 }
 163
 164 func (m *DatastoreOptions) GetKind() *KindExpression {
 165         if m != nil {
 166                 return m.Kind
 167         }
 168         return nil
 169 }
 170
 171 func (m *DatastoreOptions) GetProjection() []*Projection {
 172         if m != nil {
 173                 return m.Projection
 174         }
 175         return nil
 176 }
 177
 178 // Options defining a file or a set of files (path ending with *) within
 179 // a Google Cloud Storage bucket.
 180 type CloudStorageOptions struct {
 181         FileSet *CloudStorageOptions_FileSet `protobuf:"bytes,1,opt,name=file_set,json=fileSet" json:"file_set,omitempty"`
 182 }
 183
 184 func (m *CloudStorageOptions) Reset()                    { *m = CloudStorageOptions{} }
 185 func (m *CloudStorageOptions) String() string            { return proto.CompactTextString(m) }
 186 func (*CloudStorageOptions) ProtoMessage()               {}
 187 func (*CloudStorageOptions) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
 188
 189 func (m *CloudStorageOptions) GetFileSet() *CloudStorageOptions_FileSet {
 190         if m != nil {
 191                 return m.FileSet
 192         }
 193         return nil
 194 }
 195
 196 // Set of files to scan.
 197 type CloudStorageOptions_FileSet struct {
 198         // The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the
 199         // path is allowed.
 200         Url string `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
 201 }
 202
 203 func (m *CloudStorageOptions_FileSet) Reset()                    { *m = CloudStorageOptions_FileSet{} }
 204 func (m *CloudStorageOptions_FileSet) String() string            { return proto.CompactTextString(m) }
 205 func (*CloudStorageOptions_FileSet) ProtoMessage()               {}
 206 func (*CloudStorageOptions_FileSet) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7, 0} }
 207
 208 func (m *CloudStorageOptions_FileSet) GetUrl() string {
 209         if m != nil {
 210                 return m.Url
 211         }
 212         return ""
 213 }
 214
 215 // A location in Cloud Storage.
 216 type CloudStoragePath struct {
 217         // The url, in the format of `gs://bucket/<path>`.
 218         Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
 219 }
 220
 221 func (m *CloudStoragePath) Reset()                    { *m = CloudStoragePath{} }
 222 func (m *CloudStoragePath) String() string            { return proto.CompactTextString(m) }
 223 func (*CloudStoragePath) ProtoMessage()               {}
 224 func (*CloudStoragePath) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
 225
 226 func (m *CloudStoragePath) GetPath() string {
 227         if m != nil {
 228                 return m.Path
 229         }
 230         return ""
 231 }
 232
 233 // Options defining BigQuery table and row identifiers.
 234 type BigQueryOptions struct {
 235         // Complete BigQuery table reference.
 236         TableReference *BigQueryTable `protobuf:"bytes,1,opt,name=table_reference,json=tableReference" json:"table_reference,omitempty"`
 237         // References to fields uniquely identifying rows within the table.
 238         // Nested fields in the format, like `person.birthdate.year`, are allowed.
 239         IdentifyingFields []*FieldId `protobuf:"bytes,2,rep,name=identifying_fields,json=identifyingFields" json:"identifying_fields,omitempty"`
 240 }
 241
 242 func (m *BigQueryOptions) Reset()                    { *m = BigQueryOptions{} }
 243 func (m *BigQueryOptions) String() string            { return proto.CompactTextString(m) }
 244 func (*BigQueryOptions) ProtoMessage()               {}
 245 func (*BigQueryOptions) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }
 246
 247 func (m *BigQueryOptions) GetTableReference() *BigQueryTable {
 248         if m != nil {
 249                 return m.TableReference
 250         }
 251         return nil
 252 }
 253
 254 func (m *BigQueryOptions) GetIdentifyingFields() []*FieldId {
 255         if m != nil {
 256                 return m.IdentifyingFields
 257         }
 258         return nil
 259 }
 260
 261 // Shared message indicating Cloud storage type.
 262 type StorageConfig struct {
 263         // Types that are valid to be assigned to Type:
 264         //      *StorageConfig_DatastoreOptions
 265         //      *StorageConfig_CloudStorageOptions
 266         //      *StorageConfig_BigQueryOptions
 267         Type isStorageConfig_Type `protobuf_oneof:"type"`
 268 }
 269
 270 func (m *StorageConfig) Reset()                    { *m = StorageConfig{} }
 271 func (m *StorageConfig) String() string            { return proto.CompactTextString(m) }
 272 func (*StorageConfig) ProtoMessage()               {}
 273 func (*StorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }
 274
 275 type isStorageConfig_Type interface {
 276         isStorageConfig_Type()
 277 }
 278
 279 type StorageConfig_DatastoreOptions struct {
 280         DatastoreOptions *DatastoreOptions `protobuf:"bytes,2,opt,name=datastore_options,json=datastoreOptions,oneof"`
 281 }
 282 type StorageConfig_CloudStorageOptions struct {
 283         CloudStorageOptions *CloudStorageOptions `protobuf:"bytes,3,opt,name=cloud_storage_options,json=cloudStorageOptions,oneof"`
 284 }
 285 type StorageConfig_BigQueryOptions struct {
 286         BigQueryOptions *BigQueryOptions `protobuf:"bytes,4,opt,name=big_query_options,json=bigQueryOptions,oneof"`
 287 }
 288
 289 func (*StorageConfig_DatastoreOptions) isStorageConfig_Type()    {}
 290 func (*StorageConfig_CloudStorageOptions) isStorageConfig_Type() {}
 291 func (*StorageConfig_BigQueryOptions) isStorageConfig_Type()     {}
 292
 293 func (m *StorageConfig) GetType() isStorageConfig_Type {
 294         if m != nil {
 295                 return m.Type
 296         }
 297         return nil
 298 }
 299
 300 func (m *StorageConfig) GetDatastoreOptions() *DatastoreOptions {
 301         if x, ok := m.GetType().(*StorageConfig_DatastoreOptions); ok {
 302                 return x.DatastoreOptions
 303         }
 304         return nil
 305 }
 306
 307 func (m *StorageConfig) GetCloudStorageOptions() *CloudStorageOptions {
 308         if x, ok := m.GetType().(*StorageConfig_CloudStorageOptions); ok {
 309                 return x.CloudStorageOptions
 310         }
 311         return nil
 312 }
 313
 314 func (m *StorageConfig) GetBigQueryOptions() *BigQueryOptions {
 315         if x, ok := m.GetType().(*StorageConfig_BigQueryOptions); ok {
 316                 return x.BigQueryOptions
 317         }
 318         return nil
 319 }
 320
 321 // XXX_OneofFuncs is for the internal use of the proto package.
 322 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{}) {
 323         return _StorageConfig_OneofMarshaler, _StorageConfig_OneofUnmarshaler, _StorageConfig_OneofSizer, []interface{}{
 324                 (*StorageConfig_DatastoreOptions)(nil),
 325                 (*StorageConfig_CloudStorageOptions)(nil),
 326                 (*StorageConfig_BigQueryOptions)(nil),
 327         }
 328 }
 329
 330 func _StorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 331         m := msg.(*StorageConfig)
 332         // type
 333         switch x := m.Type.(type) {
 334         case *StorageConfig_DatastoreOptions:
 335                 b.EncodeVarint(2<<3 | proto.WireBytes)
 336                 if err := b.EncodeMessage(x.DatastoreOptions); err != nil {
 337                         return err
 338                 }
 339         case *StorageConfig_CloudStorageOptions:
 340                 b.EncodeVarint(3<<3 | proto.WireBytes)
 341                 if err := b.EncodeMessage(x.CloudStorageOptions); err != nil {
 342                         return err
 343                 }
 344         case *StorageConfig_BigQueryOptions:
 345                 b.EncodeVarint(4<<3 | proto.WireBytes)
 346                 if err := b.EncodeMessage(x.BigQueryOptions); err != nil {
 347                         return err
 348                 }
 349         case nil:
 350         default:
 351                 return fmt.Errorf("StorageConfig.Type has unexpected type %T", x)
 352         }
 353         return nil
 354 }
 355
 356 func _StorageConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 357         m := msg.(*StorageConfig)
 358         switch tag {
 359         case 2: // type.datastore_options
 360                 if wire != proto.WireBytes {
 361                         return true, proto.ErrInternalBadWireType
 362                 }
 363                 msg := new(DatastoreOptions)
 364                 err := b.DecodeMessage(msg)
 365                 m.Type = &StorageConfig_DatastoreOptions{msg}
 366                 return true, err
 367         case 3: // type.cloud_storage_options
 368                 if wire != proto.WireBytes {
 369                         return true, proto.ErrInternalBadWireType
 370                 }
 371                 msg := new(CloudStorageOptions)
 372                 err := b.DecodeMessage(msg)
 373                 m.Type = &StorageConfig_CloudStorageOptions{msg}
 374                 return true, err
 375         case 4: // type.big_query_options
 376                 if wire != proto.WireBytes {
 377                         return true, proto.ErrInternalBadWireType
 378                 }
 379                 msg := new(BigQueryOptions)
 380                 err := b.DecodeMessage(msg)
 381                 m.Type = &StorageConfig_BigQueryOptions{msg}
 382                 return true, err
 383         default:
 384                 return false, nil
 385         }
 386 }
 387
 388 func _StorageConfig_OneofSizer(msg proto.Message) (n int) {
 389         m := msg.(*StorageConfig)
 390         // type
 391         switch x := m.Type.(type) {
 392         case *StorageConfig_DatastoreOptions:
 393                 s := proto.Size(x.DatastoreOptions)
 394                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 395                 n += proto.SizeVarint(uint64(s))
 396                 n += s
 397         case *StorageConfig_CloudStorageOptions:
 398                 s := proto.Size(x.CloudStorageOptions)
 399                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 400                 n += proto.SizeVarint(uint64(s))
 401                 n += s
 402         case *StorageConfig_BigQueryOptions:
 403                 s := proto.Size(x.BigQueryOptions)
 404                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 405                 n += proto.SizeVarint(uint64(s))
 406                 n += s
 407         case nil:
 408         default:
 409                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 410         }
 411         return n
 412 }
 413
 414 // Record key for a finding in a Cloud Storage file.
 415 type CloudStorageKey struct {
 416         // Path to the file.
 417         FilePath string `protobuf:"bytes,1,opt,name=file_path,json=filePath" json:"file_path,omitempty"`
 418         // Byte offset of the referenced data in the file.
 419         StartOffset int64 `protobuf:"varint,2,opt,name=start_offset,json=startOffset" json:"start_offset,omitempty"`
 420 }
 421
 422 func (m *CloudStorageKey) Reset()                    { *m = CloudStorageKey{} }
 423 func (m *CloudStorageKey) String() string            { return proto.CompactTextString(m) }
 424 func (*CloudStorageKey) ProtoMessage()               {}
 425 func (*CloudStorageKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} }
 426
 427 func (m *CloudStorageKey) GetFilePath() string {
 428         if m != nil {
 429                 return m.FilePath
 430         }
 431         return ""
 432 }
 433
 434 func (m *CloudStorageKey) GetStartOffset() int64 {
 435         if m != nil {
 436                 return m.StartOffset
 437         }
 438         return 0
 439 }
 440
 441 // Record key for a finding in Cloud Datastore.
 442 type DatastoreKey struct {
 443         // Datastore entity key.
 444         EntityKey *Key `protobuf:"bytes,1,opt,name=entity_key,json=entityKey" json:"entity_key,omitempty"`
 445 }
 446
 447 func (m *DatastoreKey) Reset()                    { *m = DatastoreKey{} }
 448 func (m *DatastoreKey) String() string            { return proto.CompactTextString(m) }
 449 func (*DatastoreKey) ProtoMessage()               {}
 450 func (*DatastoreKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} }
 451
 452 func (m *DatastoreKey) GetEntityKey() *Key {
 453         if m != nil {
 454                 return m.EntityKey
 455         }
 456         return nil
 457 }
 458
 459 // A unique identifier for a Datastore entity.
 460 // If a key's partition ID or any of its path kinds or names are
 461 // reserved/read-only, the key is reserved/read-only.
 462 // A reserved/read-only key is forbidden in certain documented contexts.
 463 type Key struct {
 464         // Entities are partitioned into subsets, currently identified by a project
 465         // ID and namespace ID.
 466         // Queries are scoped to a single partition.
 467         PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id,json=partitionId" json:"partition_id,omitempty"`
 468         // The entity path.
 469         // An entity path consists of one or more elements composed of a kind and a
 470         // string or numerical identifier, which identify entities. The first
 471         // element identifies a _root entity_, the second element identifies
 472         // a _child_ of the root entity, the third element identifies a child of the
 473         // second entity, and so forth. The entities identified by all prefixes of
 474         // the path are called the element's _ancestors_.
 475         //
 476         // A path can never be empty, and a path can have at most 100 elements.
 477         Path []*Key_PathElement `protobuf:"bytes,2,rep,name=path" json:"path,omitempty"`
 478 }
 479
 480 func (m *Key) Reset()                    { *m = Key{} }
 481 func (m *Key) String() string            { return proto.CompactTextString(m) }
 482 func (*Key) ProtoMessage()               {}
 483 func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13} }
 484
 485 func (m *Key) GetPartitionId() *PartitionId {
 486         if m != nil {
 487                 return m.PartitionId
 488         }
 489         return nil
 490 }
 491
 492 func (m *Key) GetPath() []*Key_PathElement {
 493         if m != nil {
 494                 return m.Path
 495         }
 496         return nil
 497 }
 498
 499 // A (kind, ID/name) pair used to construct a key path.
 500 //
 501 // If either name or ID is set, the element is complete.
 502 // If neither is set, the element is incomplete.
 503 type Key_PathElement struct {
 504         // The kind of the entity.
 505         // A kind matching regex `__.*__` is reserved/read-only.
 506         // A kind must not contain more than 1500 bytes when UTF-8 encoded.
 507         // Cannot be `""`.
 508         Kind string `protobuf:"bytes,1,opt,name=kind" json:"kind,omitempty"`
 509         // The type of ID.
 510         //
 511         // Types that are valid to be assigned to IdType:
 512         //      *Key_PathElement_Id
 513         //      *Key_PathElement_Name
 514         IdType isKey_PathElement_IdType `protobuf_oneof:"id_type"`
 515 }
 516
 517 func (m *Key_PathElement) Reset()                    { *m = Key_PathElement{} }
 518 func (m *Key_PathElement) String() string            { return proto.CompactTextString(m) }
 519 func (*Key_PathElement) ProtoMessage()               {}
 520 func (*Key_PathElement) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13, 0} }
 521
 522 type isKey_PathElement_IdType interface {
 523         isKey_PathElement_IdType()
 524 }
 525
 526 type Key_PathElement_Id struct {
 527         Id int64 `protobuf:"varint,2,opt,name=id,oneof"`
 528 }
 529 type Key_PathElement_Name struct {
 530         Name string `protobuf:"bytes,3,opt,name=name,oneof"`
 531 }
 532
 533 func (*Key_PathElement_Id) isKey_PathElement_IdType()   {}
 534 func (*Key_PathElement_Name) isKey_PathElement_IdType() {}
 535
 536 func (m *Key_PathElement) GetIdType() isKey_PathElement_IdType {
 537         if m != nil {
 538                 return m.IdType
 539         }
 540         return nil
 541 }
 542
 543 func (m *Key_PathElement) GetKind() string {
 544         if m != nil {
 545                 return m.Kind
 546         }
 547         return ""
 548 }
 549
 550 func (m *Key_PathElement) GetId() int64 {
 551         if x, ok := m.GetIdType().(*Key_PathElement_Id); ok {
 552                 return x.Id
 553         }
 554         return 0
 555 }
 556
 557 func (m *Key_PathElement) GetName() string {
 558         if x, ok := m.GetIdType().(*Key_PathElement_Name); ok {
 559                 return x.Name
 560         }
 561         return ""
 562 }
 563
 564 // XXX_OneofFuncs is for the internal use of the proto package.
 565 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{}) {
 566         return _Key_PathElement_OneofMarshaler, _Key_PathElement_OneofUnmarshaler, _Key_PathElement_OneofSizer, []interface{}{
 567                 (*Key_PathElement_Id)(nil),
 568                 (*Key_PathElement_Name)(nil),
 569         }
 570 }
 571
 572 func _Key_PathElement_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 573         m := msg.(*Key_PathElement)
 574         // id_type
 575         switch x := m.IdType.(type) {
 576         case *Key_PathElement_Id:
 577                 b.EncodeVarint(2<<3 | proto.WireVarint)
 578                 b.EncodeVarint(uint64(x.Id))
 579         case *Key_PathElement_Name:
 580                 b.EncodeVarint(3<<3 | proto.WireBytes)
 581                 b.EncodeStringBytes(x.Name)
 582         case nil:
 583         default:
 584                 return fmt.Errorf("Key_PathElement.IdType has unexpected type %T", x)
 585         }
 586         return nil
 587 }
 588
 589 func _Key_PathElement_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 590         m := msg.(*Key_PathElement)
 591         switch tag {
 592         case 2: // id_type.id
 593                 if wire != proto.WireVarint {
 594                         return true, proto.ErrInternalBadWireType
 595                 }
 596                 x, err := b.DecodeVarint()
 597                 m.IdType = &Key_PathElement_Id{int64(x)}
 598                 return true, err
 599         case 3: // id_type.name
 600                 if wire != proto.WireBytes {
 601                         return true, proto.ErrInternalBadWireType
 602                 }
 603                 x, err := b.DecodeStringBytes()
 604                 m.IdType = &Key_PathElement_Name{x}
 605                 return true, err
 606         default:
 607                 return false, nil
 608         }
 609 }
 610
 611 func _Key_PathElement_OneofSizer(msg proto.Message) (n int) {
 612         m := msg.(*Key_PathElement)
 613         // id_type
 614         switch x := m.IdType.(type) {
 615         case *Key_PathElement_Id:
 616                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 617                 n += proto.SizeVarint(uint64(x.Id))
 618         case *Key_PathElement_Name:
 619                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 620                 n += proto.SizeVarint(uint64(len(x.Name)))
 621                 n += len(x.Name)
 622         case nil:
 623         default:
 624                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 625         }
 626         return n
 627 }
 628
 629 // Message for a unique key indicating a record that contains a finding.
 630 type RecordKey struct {
 631         // Types that are valid to be assigned to Type:
 632         //      *RecordKey_CloudStorageKey
 633         //      *RecordKey_DatastoreKey
 634         Type isRecordKey_Type `protobuf_oneof:"type"`
 635 }
 636
 637 func (m *RecordKey) Reset()                    { *m = RecordKey{} }
 638 func (m *RecordKey) String() string            { return proto.CompactTextString(m) }
 639 func (*RecordKey) ProtoMessage()               {}
 640 func (*RecordKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{14} }
 641
 642 type isRecordKey_Type interface {
 643         isRecordKey_Type()
 644 }
 645
 646 type RecordKey_CloudStorageKey struct {
 647         CloudStorageKey *CloudStorageKey `protobuf:"bytes,1,opt,name=cloud_storage_key,json=cloudStorageKey,oneof"`
 648 }
 649 type RecordKey_DatastoreKey struct {
 650         DatastoreKey *DatastoreKey `protobuf:"bytes,2,opt,name=datastore_key,json=datastoreKey,oneof"`
 651 }
 652
 653 func (*RecordKey_CloudStorageKey) isRecordKey_Type() {}
 654 func (*RecordKey_DatastoreKey) isRecordKey_Type()    {}
 655
 656 func (m *RecordKey) GetType() isRecordKey_Type {
 657         if m != nil {
 658                 return m.Type
 659         }
 660         return nil
 661 }
 662
 663 func (m *RecordKey) GetCloudStorageKey() *CloudStorageKey {
 664         if x, ok := m.GetType().(*RecordKey_CloudStorageKey); ok {
 665                 return x.CloudStorageKey
 666         }
 667         return nil
 668 }
 669
 670 func (m *RecordKey) GetDatastoreKey() *DatastoreKey {
 671         if x, ok := m.GetType().(*RecordKey_DatastoreKey); ok {
 672                 return x.DatastoreKey
 673         }
 674         return nil
 675 }
 676
 677 // XXX_OneofFuncs is for the internal use of the proto package.
 678 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{}) {
 679         return _RecordKey_OneofMarshaler, _RecordKey_OneofUnmarshaler, _RecordKey_OneofSizer, []interface{}{
 680                 (*RecordKey_CloudStorageKey)(nil),
 681                 (*RecordKey_DatastoreKey)(nil),
 682         }
 683 }
 684
 685 func _RecordKey_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 686         m := msg.(*RecordKey)
 687         // type
 688         switch x := m.Type.(type) {
 689         case *RecordKey_CloudStorageKey:
 690                 b.EncodeVarint(1<<3 | proto.WireBytes)
 691                 if err := b.EncodeMessage(x.CloudStorageKey); err != nil {
 692                         return err
 693                 }
 694         case *RecordKey_DatastoreKey:
 695                 b.EncodeVarint(2<<3 | proto.WireBytes)
 696                 if err := b.EncodeMessage(x.DatastoreKey); err != nil {
 697                         return err
 698                 }
 699         case nil:
 700         default:
 701                 return fmt.Errorf("RecordKey.Type has unexpected type %T", x)
 702         }
 703         return nil
 704 }
 705
 706 func _RecordKey_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 707         m := msg.(*RecordKey)
 708         switch tag {
 709         case 1: // type.cloud_storage_key
 710                 if wire != proto.WireBytes {
 711                         return true, proto.ErrInternalBadWireType
 712                 }
 713                 msg := new(CloudStorageKey)
 714                 err := b.DecodeMessage(msg)
 715                 m.Type = &RecordKey_CloudStorageKey{msg}
 716                 return true, err
 717         case 2: // type.datastore_key
 718                 if wire != proto.WireBytes {
 719                         return true, proto.ErrInternalBadWireType
 720                 }
 721                 msg := new(DatastoreKey)
 722                 err := b.DecodeMessage(msg)
 723                 m.Type = &RecordKey_DatastoreKey{msg}
 724                 return true, err
 725         default:
 726                 return false, nil
 727         }
 728 }
 729
 730 func _RecordKey_OneofSizer(msg proto.Message) (n int) {
 731         m := msg.(*RecordKey)
 732         // type
 733         switch x := m.Type.(type) {
 734         case *RecordKey_CloudStorageKey:
 735                 s := proto.Size(x.CloudStorageKey)
 736                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 737                 n += proto.SizeVarint(uint64(s))
 738                 n += s
 739         case *RecordKey_DatastoreKey:
 740                 s := proto.Size(x.DatastoreKey)
 741                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 742                 n += proto.SizeVarint(uint64(s))
 743                 n += s
 744         case nil:
 745         default:
 746                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 747         }
 748         return n
 749 }
 750
 751 // Message defining the location of a BigQuery table. A table is uniquely
 752 // identified  by its project_id, dataset_id, and table_name. Within a query
 753 // a table is often referenced with a string in the format of:
 754 // `<project_id>:<dataset_id>.<table_id>` or
 755 // `<project_id>.<dataset_id>.<table_id>`.
 756 type BigQueryTable struct {
 757         // The Google Cloud Platform project ID of the project containing the table.
 758         // If omitted, project ID is inferred from the API call.
 759         ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
 760         // Dataset ID of the table.
 761         DatasetId string `protobuf:"bytes,2,opt,name=dataset_id,json=datasetId" json:"dataset_id,omitempty"`
 762         // Name of the table.
 763         TableId string `protobuf:"bytes,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
 764 }
 765
 766 func (m *BigQueryTable) Reset()                    { *m = BigQueryTable{} }
 767 func (m *BigQueryTable) String() string            { return proto.CompactTextString(m) }
 768 func (*BigQueryTable) ProtoMessage()               {}
 769 func (*BigQueryTable) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{15} }
 770
 771 func (m *BigQueryTable) GetProjectId() string {
 772         if m != nil {
 773                 return m.ProjectId
 774         }
 775         return ""
 776 }
 777
 778 func (m *BigQueryTable) GetDatasetId() string {
 779         if m != nil {
 780                 return m.DatasetId
 781         }
 782         return ""
 783 }
 784
 785 func (m *BigQueryTable) GetTableId() string {
 786         if m != nil {
 787                 return m.TableId
 788         }
 789         return ""
 790 }
 791
 792 func init() {
 793         proto.RegisterType((*InfoType)(nil), "google.privacy.dlp.v2beta1.InfoType")
 794         proto.RegisterType((*FieldId)(nil), "google.privacy.dlp.v2beta1.FieldId")
 795         proto.RegisterType((*PartitionId)(nil), "google.privacy.dlp.v2beta1.PartitionId")
 796         proto.RegisterType((*KindExpression)(nil), "google.privacy.dlp.v2beta1.KindExpression")
 797         proto.RegisterType((*PropertyReference)(nil), "google.privacy.dlp.v2beta1.PropertyReference")
 798         proto.RegisterType((*Projection)(nil), "google.privacy.dlp.v2beta1.Projection")
 799         proto.RegisterType((*DatastoreOptions)(nil), "google.privacy.dlp.v2beta1.DatastoreOptions")
 800         proto.RegisterType((*CloudStorageOptions)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions")
 801         proto.RegisterType((*CloudStorageOptions_FileSet)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet")
 802         proto.RegisterType((*CloudStoragePath)(nil), "google.privacy.dlp.v2beta1.CloudStoragePath")
 803         proto.RegisterType((*BigQueryOptions)(nil), "google.privacy.dlp.v2beta1.BigQueryOptions")
 804         proto.RegisterType((*StorageConfig)(nil), "google.privacy.dlp.v2beta1.StorageConfig")
 805         proto.RegisterType((*CloudStorageKey)(nil), "google.privacy.dlp.v2beta1.CloudStorageKey")
 806         proto.RegisterType((*DatastoreKey)(nil), "google.privacy.dlp.v2beta1.DatastoreKey")
 807         proto.RegisterType((*Key)(nil), "google.privacy.dlp.v2beta1.Key")
 808         proto.RegisterType((*Key_PathElement)(nil), "google.privacy.dlp.v2beta1.Key.PathElement")
 809         proto.RegisterType((*RecordKey)(nil), "google.privacy.dlp.v2beta1.RecordKey")
 810         proto.RegisterType((*BigQueryTable)(nil), "google.privacy.dlp.v2beta1.BigQueryTable")
 811 }
 812
 813 func init() { proto.RegisterFile("google/privacy/dlp/v2beta1/storage.proto", fileDescriptor1) }
 814
 815 var fileDescriptor1 = []byte{
 816         // 909 bytes of a gzipped FileDescriptorProto
 817         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xef, 0x6e, 0x1b, 0x45,
 818         0x10, 0xcf, 0xd9, 0x56, 0x13, 0x8f, 0x9d, 0xc6, 0xbe, 0x82, 0x64, 0x5c, 0xda, 0xb4, 0x07, 0x6a,
 819         0x43, 0x03, 0x77, 0xc2, 0x7c, 0xe0, 0x03, 0xa2, 0x48, 0x6e, 0x1a, 0x62, 0x22, 0x35, 0xe9, 0x36,
 820         0x02, 0x15, 0x3e, 0x9c, 0xd6, 0xb7, 0x7b, 0x97, 0xa5, 0xe7, 0xdb, 0xe5, 0x6e, 0x5d, 0x71, 0x2f,
 821         0x80, 0x78, 0x16, 0x1e, 0x00, 0x89, 0x4f, 0xbc, 0x0d, 0xe2, 0x31, 0xd0, 0xfe, 0xf1, 0xf9, 0x62,
 822         0x8c, 0x1b, 0xa4, 0x7e, 0x5b, 0xcf, 0xcd, 0xfc, 0x66, 0xe7, 0x37, 0xbf, 0x99, 0x35, 0x1c, 0x24,
 823         0x9c, 0x27, 0x29, 0x0d, 0x44, 0xce, 0x5e, 0xe3, 0xa8, 0x0c, 0x48, 0x2a, 0x82, 0xd7, 0xa3, 0x29,
 824         0x95, 0xf8, 0xd3, 0xa0, 0x90, 0x3c, 0xc7, 0x09, 0xf5, 0x45, 0xce, 0x25, 0x77, 0x87, 0xc6, 0xd3,
 825         0xb7, 0x9e, 0x3e, 0x49, 0x85, 0x6f, 0x3d, 0x87, 0xef, 0x5b, 0x14, 0x2c, 0x58, 0x80, 0xb3, 0x8c,
 826         0x4b, 0x2c, 0x19, 0xcf, 0x0a, 0x13, 0x39, 0xdc, 0xaf, 0x72, 0x70, 0xc9, 0xa7, 0xf3, 0x38, 0x90,
 827         0x6c, 0x46, 0x0b, 0x89, 0x67, 0xc2, 0x38, 0x78, 0x77, 0x61, 0x67, 0x92, 0xc5, 0xfc, 0xa2, 0x14,
 828         0xd4, 0x75, 0xa1, 0x95, 0xe1, 0x19, 0x1d, 0x38, 0xf7, 0x9c, 0x83, 0x36, 0xd2, 0x67, 0xef, 0x11,
 829         0x6c, 0x1f, 0x33, 0x9a, 0x92, 0x09, 0x71, 0xf7, 0xa1, 0x13, 0xf1, 0x74, 0x3e, 0xcb, 0xc2, 0x9a,
 830         0x17, 0x18, 0xd3, 0x33, 0xe5, 0x7b, 0x06, 0x9d, 0x73, 0x9c, 0x4b, 0xa6, 0x2e, 0x30, 0x21, 0xee,
 831         0x1d, 0x00, 0x91, 0xf3, 0x1f, 0x69, 0x24, 0x43, 0x46, 0x06, 0x0d, 0xed, 0xde, 0xb6, 0x96, 0x09,
 832         0x71, 0xef, 0x43, 0x57, 0xe1, 0x14, 0x02, 0x47, 0x54, 0x39, 0xb4, 0xb4, 0x43, 0xa7, 0xb2, 0x4d,
 833         0x88, 0xf7, 0x21, 0xdc, 0x3c, 0x65, 0x19, 0x79, 0xfa, 0xb3, 0xc8, 0x69, 0x51, 0x30, 0x9e, 0xad,
 834         0xbd, 0xe2, 0x43, 0xe8, 0x9f, 0xe7, 0x5c, 0xd0, 0x5c, 0x96, 0x88, 0xc6, 0x34, 0xa7, 0x59, 0xb4,
 835         0xac, 0xa5, 0x51, 0x73, 0xfc, 0x0e, 0xe0, 0xdc, 0xa4, 0x57, 0x50, 0x13, 0xd8, 0x11, 0x36, 0x4c,
 836         0xc3, 0x75, 0x46, 0x9f, 0xf8, 0xff, 0xcd, 0xb3, 0xff, 0xaf, 0x14, 0xa8, 0x0a, 0xf7, 0xfe, 0x72,
 837         0xa0, 0x77, 0x84, 0x25, 0x56, 0x5d, 0xa3, 0x67, 0x42, 0x37, 0xc0, 0xfd, 0x06, 0xba, 0x62, 0xc1,
 838         0x86, 0xaa, 0xcf, 0xe4, 0x78, 0xb8, 0x31, 0xc7, 0x92, 0x3d, 0xd4, 0x11, 0x35, 0x2a, 0x1f, 0x43,
 839         0xeb, 0x15, 0xcb, 0x0c, 0x89, 0x9d, 0xd1, 0xa3, 0x4d, 0x18, 0x57, 0x09, 0x43, 0x3a, 0xce, 0x3d,
 840         0xae, 0x5a, 0xc1, 0x78, 0x36, 0x68, 0xde, 0x6b, 0x1e, 0x74, 0x46, 0x0f, 0xde, 0x50, 0xad, 0xf5,
 841         0x46, 0xb5, 0x48, 0xef, 0x17, 0x07, 0x6e, 0x3d, 0x49, 0xf9, 0x9c, 0xbc, 0x30, 0xfa, 0x5c, 0xd4,
 842         0x8a, 0x60, 0x27, 0x66, 0x29, 0x0d, 0x0b, 0x2a, 0x6d, 0x9d, 0x9f, 0x6f, 0x42, 0x5f, 0x03, 0xe1,
 843         0x1f, 0xb3, 0x94, 0xbe, 0xa0, 0x12, 0x6d, 0xc7, 0xe6, 0x30, 0xbc, 0xad, 0x94, 0xa7, 0x8f, 0x6e,
 844         0x0f, 0x9a, 0xf3, 0x3c, 0xb5, 0x4d, 0x57, 0x47, 0xef, 0x01, 0xf4, 0xea, 0x20, 0xe7, 0x58, 0x5e,
 845         0xaa, 0x96, 0x0b, 0x2c, 0x2f, 0x17, 0xda, 0x50, 0x67, 0xef, 0x0f, 0x07, 0xf6, 0xc6, 0x2c, 0x79,
 846         0x3e, 0xa7, 0x79, 0xb9, 0xbc, 0xec, 0x9e, 0xc4, 0xd3, 0x94, 0x86, 0xf9, 0xa2, 0x95, 0xf6, 0xce,
 847         0x1f, 0x6d, 0xba, 0xf3, 0x02, 0xe5, 0x42, 0x85, 0xa2, 0x9b, 0x1a, 0x61, 0x29, 0x37, 0x04, 0x2e,
 848         0x23, 0x34, 0x93, 0x2c, 0x2e, 0x59, 0x96, 0x84, 0xb1, 0x1a, 0x99, 0x62, 0xd0, 0xd0, 0x44, 0x7f,
 849         0xb0, 0x09, 0xd6, 0x0e, 0x17, 0xea, 0xd7, 0xc2, 0xb5, 0xad, 0xf0, 0x7e, 0x6f, 0xc0, 0xae, 0xad,
 850         0xef, 0x09, 0xcf, 0x62, 0x96, 0xb8, 0x3f, 0x40, 0x9f, 0x2c, 0x64, 0x16, 0x72, 0x53, 0x8e, 0xd5,
 851         0xc4, 0xc7, 0x9b, 0x92, 0xac, 0x6a, 0xf3, 0x64, 0x0b, 0xf5, 0xc8, 0xaa, 0x5e, 0x29, 0xbc, 0x1b,
 852         0x29, 0x4a, 0x43, 0xbb, 0x7b, 0xaa, 0x04, 0x4d, 0x9d, 0x20, 0xf8, 0x9f, 0x0d, 0x3d, 0xd9, 0x42,
 853         0xb7, 0xa2, 0x35, 0x52, 0x79, 0x09, 0xfd, 0x29, 0x4b, 0xc2, 0x9f, 0x14, 0x97, 0x55, 0x8a, 0x96,
 854         0x4e, 0x71, 0x78, 0x1d, 0xfe, 0x97, 0xf0, 0x7b, 0xd3, 0xab, 0xa6, 0xf1, 0x0d, 0x68, 0xc9, 0x52,
 855         0x50, 0xef, 0x39, 0xec, 0xd5, 0x2f, 0x74, 0x4a, 0x4b, 0xf7, 0x36, 0xb4, 0xb5, 0x40, 0x6b, 0x02,
 856         0xd1, 0x8a, 0xd5, 0xc2, 0xb9, 0x0f, 0xdd, 0x42, 0xe2, 0x5c, 0x86, 0x3c, 0x8e, 0x95, 0x82, 0x15,
 857         0xa3, 0x4d, 0xd4, 0xd1, 0xb6, 0x33, 0x6d, 0xf2, 0x9e, 0x41, 0xb7, 0x22, 0x51, 0xe1, 0x3d, 0x06,
 858         0x50, 0xed, 0x92, 0x65, 0xf8, 0x8a, 0x2e, 0xd6, 0xc7, 0xfe, 0xc6, 0xb1, 0xa4, 0x25, 0x6a, 0x9b,
 859         0x90, 0x53, 0x5a, 0x7a, 0x7f, 0x3b, 0xd0, 0x54, 0x38, 0x6f, 0x73, 0x49, 0x7c, 0x65, 0xf5, 0x6f,
 860         0x54, 0x77, 0xf8, 0x86, 0xdb, 0xf8, 0xaa, 0xf4, 0xa7, 0x29, 0x9d, 0xd1, 0x4c, 0x9a, 0x61, 0x19,
 861         0x5e, 0xa8, 0xfd, 0x5d, 0x19, 0xd5, 0x3c, 0xe9, 0xa5, 0x63, 0xe7, 0x49, 0x2f, 0x92, 0x1e, 0x34,
 862         0xec, 0x2e, 0x6f, 0x9e, 0x6c, 0xa1, 0x06, 0x23, 0xee, 0x3b, 0x76, 0xd1, 0x2a, 0x95, 0xb4, 0x4f,
 863         0xb6, 0xcc, 0xaa, 0x1d, 0xb7, 0x61, 0x9b, 0x91, 0x50, 0x77, 0xe3, 0x4f, 0x07, 0xda, 0x88, 0x46,
 864         0x3c, 0x27, 0xaa, 0xe0, 0x97, 0xd0, 0xbf, 0xaa, 0xb2, 0x25, 0x7f, 0x87, 0xd7, 0x55, 0xd8, 0x29,
 865         0x2d, 0x55, 0xfb, 0xa3, 0x95, 0x1e, 0x9f, 0xc1, 0xee, 0x72, 0x3a, 0x14, 0xac, 0x99, 0x8c, 0x83,
 866         0x6b, 0x4d, 0x86, 0xc1, 0xec, 0x92, 0xda, 0xef, 0x4a, 0x4f, 0x97, 0xb0, 0x7b, 0x65, 0xfa, 0x57,
 867         0x5e, 0x36, 0x67, 0xf5, 0x65, 0xbb, 0x03, 0xa0, 0x71, 0x68, 0xfd, 0xe1, 0xb3, 0x96, 0x09, 0x71,
 868         0xdf, 0x83, 0x1d, 0xb3, 0x7f, 0x18, 0x31, 0xac, 0xa1, 0x6d, 0xfd, 0x7b, 0x42, 0xc6, 0xbf, 0x3a,
 869         0x70, 0x37, 0xe2, 0xb3, 0x0d, 0x37, 0x1e, 0xc3, 0x51, 0x2a, 0x16, 0x5b, 0xcf, 0xf9, 0xfe, 0x4b,
 870         0xeb, 0x99, 0xf0, 0x14, 0x67, 0x89, 0xcf, 0xf3, 0x24, 0x48, 0x68, 0xa6, 0x9f, 0xf6, 0xc0, 0x7c,
 871         0xc2, 0x82, 0x15, 0xeb, 0xfe, 0x62, 0x7c, 0x41, 0x52, 0xf1, 0x5b, 0x63, 0xf0, 0xb5, 0x89, 0xd7,
 872         0xf4, 0xfa, 0x47, 0xa9, 0xf0, 0xbf, 0x1d, 0x8d, 0xd5, 0xe7, 0xe9, 0x0d, 0x0d, 0xf2, 0xd9, 0x3f,
 873         0x01, 0x00, 0x00, 0xff, 0xff, 0x8c, 0xe7, 0xe9, 0x4f, 0xa6, 0x08, 0x00, 0x00,
 874 }