// Code generated by protoc-gen-go.
// source: google/privacy/dlp/v2beta1/storage.proto
// DO NOT EDIT!

package dlp

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
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

// Type of information detected by the API.
type InfoType struct {
	// Name of the information type, provided by the API call ListInfoTypes.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

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

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

// General identifier of a data field in a storage service.
type FieldId struct {
	// Column name describing the field.
	ColumnName string `protobuf:"bytes,1,opt,name=column_name,json=columnName" json:"column_name,omitempty"`
}

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

func (m *FieldId) GetColumnName() string {
	if m != nil {
		return m.ColumnName
	}
	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" 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" json:"namespace_id,omitempty"`
}

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

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" json:"name,omitempty"`
}

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

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

// A reference to a property relative to the Datastore kind expressions.
type PropertyReference struct {
	// The name of the property.
	// If name includes "."s, it may be interpreted as a property name path.
	Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
}

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

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

// A representation of a Datastore property in a projection.
type Projection struct {
	// The property to project.
	Property *PropertyReference `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
}

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

func (m *Projection) GetProperty() *PropertyReference {
	if m != nil {
		return m.Property
	}
	return nil
}

// 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" json:"partition_id,omitempty"`
	// The kind to process.
	Kind *KindExpression `protobuf:"bytes,2,opt,name=kind" json:"kind,omitempty"`
	// Properties to scan. If none are specified, all properties will be scanned
	// by default.
	Projection []*Projection `protobuf:"bytes,3,rep,name=projection" json:"projection,omitempty"`
}

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

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
}

func (m *DatastoreOptions) GetProjection() []*Projection {
	if m != nil {
		return m.Projection
	}
	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" json:"file_set,omitempty"`
}

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

func (m *CloudStorageOptions) GetFileSet() *CloudStorageOptions_FileSet {
	if m != nil {
		return m.FileSet
	}
	return nil
}

// 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" json:"url,omitempty"`
}

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 fileDescriptor1, []int{7, 0} }

func (m *CloudStorageOptions_FileSet) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

// Shared message indicating Cloud storage type.
type StorageConfig struct {
	// Types that are valid to be assigned to Type:
	//	*StorageConfig_DatastoreOptions
	//	*StorageConfig_CloudStorageOptions
	Type isStorageConfig_Type `protobuf_oneof:"type"`
}

func (m *StorageConfig) Reset()                    { *m = StorageConfig{} }
func (m *StorageConfig) String() string            { return proto.CompactTextString(m) }
func (*StorageConfig) ProtoMessage()               {}
func (*StorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }

type isStorageConfig_Type interface {
	isStorageConfig_Type()
}

type StorageConfig_DatastoreOptions struct {
	DatastoreOptions *DatastoreOptions `protobuf:"bytes,2,opt,name=datastore_options,json=datastoreOptions,oneof"`
}
type StorageConfig_CloudStorageOptions struct {
	CloudStorageOptions *CloudStorageOptions `protobuf:"bytes,3,opt,name=cloud_storage_options,json=cloudStorageOptions,oneof"`
}

func (*StorageConfig_DatastoreOptions) isStorageConfig_Type()    {}
func (*StorageConfig_CloudStorageOptions) 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
}

// 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),
	}
}

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 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
	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 += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StorageConfig_CloudStorageOptions:
		s := proto.Size(x.CloudStorageOptions)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Record key for a finding in a Cloud Storage file.
type CloudStorageKey struct {
	// Path to the file.
	FilePath string `protobuf:"bytes,1,opt,name=file_path,json=filePath" json:"file_path,omitempty"`
	// Byte offset of the referenced data in the file.
	StartOffset int64 `protobuf:"varint,2,opt,name=start_offset,json=startOffset" json:"start_offset,omitempty"`
}

func (m *CloudStorageKey) Reset()                    { *m = CloudStorageKey{} }
func (m *CloudStorageKey) String() string            { return proto.CompactTextString(m) }
func (*CloudStorageKey) ProtoMessage()               {}
func (*CloudStorageKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }

func (m *CloudStorageKey) GetFilePath() string {
	if m != nil {
		return m.FilePath
	}
	return ""
}

func (m *CloudStorageKey) GetStartOffset() int64 {
	if m != nil {
		return m.StartOffset
	}
	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" json:"entity_key,omitempty"`
}

func (m *DatastoreKey) Reset()                    { *m = DatastoreKey{} }
func (m *DatastoreKey) String() string            { return proto.CompactTextString(m) }
func (*DatastoreKey) ProtoMessage()               {}
func (*DatastoreKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }

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" 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" json:"path,omitempty"`
}

func (m *Key) Reset()                    { *m = Key{} }
func (m *Key) String() string            { return proto.CompactTextString(m) }
func (*Key) ProtoMessage()               {}
func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} }

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" 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"`
}

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 fileDescriptor1, []int{11, 0} }

type isKey_PathElement_IdType interface {
	isKey_PathElement_IdType()
}

type Key_PathElement_Id struct {
	Id int64 `protobuf:"varint,2,opt,name=id,oneof"`
}
type Key_PathElement_Name struct {
	Name string `protobuf:"bytes,3,opt,name=name,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) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

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 += proto.SizeVarint(2<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.Id))
	case *Key_PathElement_Name:
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		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_CloudStorageKey
	//	*RecordKey_DatastoreKey
	Type isRecordKey_Type `protobuf_oneof:"type"`
}

func (m *RecordKey) Reset()                    { *m = RecordKey{} }
func (m *RecordKey) String() string            { return proto.CompactTextString(m) }
func (*RecordKey) ProtoMessage()               {}
func (*RecordKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} }

type isRecordKey_Type interface {
	isRecordKey_Type()
}

type RecordKey_CloudStorageKey struct {
	CloudStorageKey *CloudStorageKey `protobuf:"bytes,1,opt,name=cloud_storage_key,json=cloudStorageKey,oneof"`
}
type RecordKey_DatastoreKey struct {
	DatastoreKey *DatastoreKey `protobuf:"bytes,2,opt,name=datastore_key,json=datastoreKey,oneof"`
}

func (*RecordKey_CloudStorageKey) isRecordKey_Type() {}
func (*RecordKey_DatastoreKey) isRecordKey_Type()    {}

func (m *RecordKey) GetType() isRecordKey_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *RecordKey) GetCloudStorageKey() *CloudStorageKey {
	if x, ok := m.GetType().(*RecordKey_CloudStorageKey); ok {
		return x.CloudStorageKey
	}
	return nil
}

func (m *RecordKey) GetDatastoreKey() *DatastoreKey {
	if x, ok := m.GetType().(*RecordKey_DatastoreKey); ok {
		return x.DatastoreKey
	}
	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_CloudStorageKey)(nil),
		(*RecordKey_DatastoreKey)(nil),
	}
}

func _RecordKey_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*RecordKey)
	// type
	switch x := m.Type.(type) {
	case *RecordKey_CloudStorageKey:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CloudStorageKey); err != nil {
			return err
		}
	case *RecordKey_DatastoreKey:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DatastoreKey); 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 1: // type.cloud_storage_key
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CloudStorageKey)
		err := b.DecodeMessage(msg)
		m.Type = &RecordKey_CloudStorageKey{msg}
		return true, err
	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
	default:
		return false, nil
	}
}

func _RecordKey_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*RecordKey)
	// type
	switch x := m.Type.(type) {
	case *RecordKey_CloudStorageKey:
		s := proto.Size(x.CloudStorageKey)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RecordKey_DatastoreKey:
		s := proto.Size(x.DatastoreKey)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*InfoType)(nil), "google.privacy.dlp.v2beta1.InfoType")
	proto.RegisterType((*FieldId)(nil), "google.privacy.dlp.v2beta1.FieldId")
	proto.RegisterType((*PartitionId)(nil), "google.privacy.dlp.v2beta1.PartitionId")
	proto.RegisterType((*KindExpression)(nil), "google.privacy.dlp.v2beta1.KindExpression")
	proto.RegisterType((*PropertyReference)(nil), "google.privacy.dlp.v2beta1.PropertyReference")
	proto.RegisterType((*Projection)(nil), "google.privacy.dlp.v2beta1.Projection")
	proto.RegisterType((*DatastoreOptions)(nil), "google.privacy.dlp.v2beta1.DatastoreOptions")
	proto.RegisterType((*CloudStorageOptions)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions")
	proto.RegisterType((*CloudStorageOptions_FileSet)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet")
	proto.RegisterType((*StorageConfig)(nil), "google.privacy.dlp.v2beta1.StorageConfig")
	proto.RegisterType((*CloudStorageKey)(nil), "google.privacy.dlp.v2beta1.CloudStorageKey")
	proto.RegisterType((*DatastoreKey)(nil), "google.privacy.dlp.v2beta1.DatastoreKey")
	proto.RegisterType((*Key)(nil), "google.privacy.dlp.v2beta1.Key")
	proto.RegisterType((*Key_PathElement)(nil), "google.privacy.dlp.v2beta1.Key.PathElement")
	proto.RegisterType((*RecordKey)(nil), "google.privacy.dlp.v2beta1.RecordKey")
}

func init() { proto.RegisterFile("google/privacy/dlp/v2beta1/storage.proto", fileDescriptor1) }

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