dlp

type AnalyzeDataSourceRiskRequest struct {
	// Privacy metric to compute.
	PrivacyMetric *PrivacyMetric `protobuf:"bytes,1,opt,name=privacy_metric,json=privacyMetric" json:"privacy_metric,omitempty"`
	// Input dataset to compute metrics over.
	SourceTable *BigQueryTable `protobuf:"bytes,3,opt,name=source_table,json=sourceTable" json:"source_table,omitempty"`
}

type BigQueryOptions struct {
	// Complete BigQuery table reference.
	TableReference *BigQueryTable `protobuf:"bytes,1,opt,name=table_reference,json=tableReference" 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" json:"identifying_fields,omitempty"`
}

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" json:"project_id,omitempty"`
	// Dataset ID of the table.
	DatasetId string `protobuf:"bytes,2,opt,name=dataset_id,json=datasetId" json:"dataset_id,omitempty"`
	// Name of the table.
	TableId string `protobuf:"bytes,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
}

type BucketingConfig struct {
	Buckets []*BucketingConfig_Bucket `protobuf:"bytes,1,rep,name=buckets" json:"buckets,omitempty"`
}

type BucketingConfig_Bucket struct {
	// Lower bound of the range, inclusive. Type should be the same as max if
	// used.
	Min *Value `protobuf:"bytes,1,opt,name=min" json:"min,omitempty"`
	// Upper bound of the range, exclusive; type must match min.
	Max *Value `protobuf:"bytes,2,opt,name=max" json:"max,omitempty"`
	// Replacement value for this bucket. If not provided
	// the default behavior will be to hyphenate the min-max range.
	ReplacementValue *Value `protobuf:"bytes,3,opt,name=replacement_value,json=replacementValue" json:"replacement_value,omitempty"`
}

type CategoryDescription struct {
	// Internal name of the category.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Human readable form of the category name.
	DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
}

type CharacterMaskConfig struct {
	// Character to mask the sensitive values—for example, "*" for an
	// alphabetic string such as name, or "0" for a numeric string such as ZIP
	// code or credit card number. String must have length 1. If not supplied, we
	// will default to "*" for strings, 0 for digits.
	MaskingCharacter string `protobuf:"bytes,1,opt,name=masking_character,json=maskingCharacter" json:"masking_character,omitempty"`
	// Number of characters to mask. If not set, all matching chars will be
	// masked. Skipped characters do not count towards this tally.
	NumberToMask int32 `protobuf:"varint,2,opt,name=number_to_mask,json=numberToMask" json:"number_to_mask,omitempty"`
	// Mask characters in reverse order. For example, if `masking_character` is
	// '0', number_to_mask is 14, and `reverse_order` is false, then
	// 1234-5678-9012-3456 -> 00000000000000-3456
	// If `masking_character` is '*', `number_to_mask` is 3, and `reverse_order`
	// is true, then 12345 -> 12***
	ReverseOrder bool `protobuf:"varint,3,opt,name=reverse_order,json=reverseOrder" json:"reverse_order,omitempty"`
	// When masking a string, items in this list will be skipped when replacing.
	// For example, if your string is 555-555-5555 and you ask us to skip `-` and
	// mask 5 chars with * we would produce ***-*55-5555.
	CharactersToIgnore []*CharsToIgnore `protobuf:"bytes,4,rep,name=characters_to_ignore,json=charactersToIgnore" json:"characters_to_ignore,omitempty"`
}

type CharsToIgnore struct {
	// Types that are valid to be assigned to Characters:
	//	*CharsToIgnore_CharactersToSkip
	//	*CharsToIgnore_CommonCharactersToIgnore
	Characters isCharsToIgnore_Characters `protobuf_oneof:"characters"`
}

type CharsToIgnore_CharacterGroup int32

type CharsToIgnore_CharactersToSkip struct {
	CharactersToSkip string `protobuf:"bytes,1,opt,name=characters_to_skip,json=charactersToSkip,oneof"`
}

type CharsToIgnore_CommonCharactersToIgnore struct {
	CommonCharactersToIgnore CharsToIgnore_CharacterGroup `` /* 153-byte string literal not displayed */
}

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

type CloudStorageOptions struct {
	FileSet *CloudStorageOptions_FileSet `protobuf:"bytes,1,opt,name=file_set,json=fileSet" json:"file_set,omitempty"`
}

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

type CloudStoragePath struct {
	// The url, in the format of `gs://bucket/<path>`.
	Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
}

type Color struct {
	// The amount of red in the color as a value in the interval [0, 1].
	Red float32 `protobuf:"fixed32,1,opt,name=red" json:"red,omitempty"`
	// The amount of green in the color as a value in the interval [0, 1].
	Green float32 `protobuf:"fixed32,2,opt,name=green" json:"green,omitempty"`
	// The amount of blue in the color as a value in the interval [0, 1].
	Blue float32 `protobuf:"fixed32,3,opt,name=blue" json:"blue,omitempty"`
}

type ContentItem struct {
	// Type of the content, as defined in Content-Type HTTP header.
	// Supported types are: all "text" types, octet streams, PNG images,
	// JPEG images.
	Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
	// Data of the item either in the byte array or UTF-8 string form.
	//
	// Types that are valid to be assigned to DataItem:
	//	*ContentItem_Data
	//	*ContentItem_Value
	//	*ContentItem_Table
	DataItem isContentItem_DataItem `protobuf_oneof:"data_item"`
}

type ContentItem_Data struct {
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type ContentItem_Table struct {
	Table *Table `protobuf:"bytes,4,opt,name=table,oneof"`
}

type ContentItem_Value struct {
	Value string `protobuf:"bytes,3,opt,name=value,oneof"`
}

type CreateInspectOperationRequest struct {
	// Configuration for the inspector.
	InspectConfig *InspectConfig `protobuf:"bytes,1,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
	// Specification of the data set to process.
	StorageConfig *StorageConfig `protobuf:"bytes,2,opt,name=storage_config,json=storageConfig" json:"storage_config,omitempty"`
	// Optional location to store findings.
	OutputConfig *OutputStorageConfig `protobuf:"bytes,3,opt,name=output_config,json=outputConfig" json:"output_config,omitempty"`
	// Additional configuration settings for long running operations.
	OperationConfig *OperationConfig `protobuf:"bytes,5,opt,name=operation_config,json=operationConfig" json:"operation_config,omitempty"`
}

type CryptoHashConfig struct {
	// The key used by the hash function.
	CryptoKey *CryptoKey `protobuf:"bytes,1,opt,name=crypto_key,json=cryptoKey" json:"crypto_key,omitempty"`
}

type CryptoKey struct {
	// Types that are valid to be assigned to Source:
	//	*CryptoKey_Transient
	//	*CryptoKey_Unwrapped
	//	*CryptoKey_KmsWrapped
	Source isCryptoKey_Source `protobuf_oneof:"source"`
}

type CryptoKey_KmsWrapped struct {
	KmsWrapped *KmsWrappedCryptoKey `protobuf:"bytes,3,opt,name=kms_wrapped,json=kmsWrapped,oneof"`
}

type CryptoKey_Transient struct {
	Transient *TransientCryptoKey `protobuf:"bytes,1,opt,name=transient,oneof"`
}

type CryptoKey_Unwrapped struct {
	Unwrapped *UnwrappedCryptoKey `protobuf:"bytes,2,opt,name=unwrapped,oneof"`
}

type CryptoReplaceFfxFpeConfig struct {
	// The key used by the encryption algorithm. [required]
	CryptoKey *CryptoKey `protobuf:"bytes,1,opt,name=crypto_key,json=cryptoKey" json:"crypto_key,omitempty"`
	// A context may be used for higher security since the same
	// identifier in two different contexts likely will be given a distinct
	// surrogate. The principle is that the likeliness is inversely related
	// to the ratio of the number of distinct identifiers per context over the
	// number of possible surrogates: As long as this ratio is small, the
	// likehood is large.
	//
	// If the context is not set, a default tweak will be used.
	// If the context is set but:
	//
	// 1. there is no record present when transforming a given value or
	// 1. the field is not present when transforming a given value,
	//
	// a default tweak will be used.
	//
	// Note that case (1) is expected when an `InfoTypeTransformation` is
	// applied to both structured and non-structured `ContentItem`s.
	// Currently, the referenced field may be of value type integer or string.
	//
	// The tweak is constructed as a sequence of bytes in big endian byte order
	// such that:
	//
	// - a 64 bit integer is encoded followed by a single byte of value 1
	// - a string is encoded in UTF-8 format followed by a single byte of value 2
	//
	// This is also known as the 'tweak', as in tweakable encryption.
	Context *FieldId `protobuf:"bytes,2,opt,name=context" json:"context,omitempty"`
	// Types that are valid to be assigned to Alphabet:
	//	*CryptoReplaceFfxFpeConfig_CommonAlphabet
	//	*CryptoReplaceFfxFpeConfig_CustomAlphabet
	//	*CryptoReplaceFfxFpeConfig_Radix
	Alphabet isCryptoReplaceFfxFpeConfig_Alphabet `protobuf_oneof:"alphabet"`
}

type CryptoReplaceFfxFpeConfig_CommonAlphabet struct {
	CommonAlphabet CryptoReplaceFfxFpeConfig_FfxCommonNativeAlphabet `` /* 152-byte string literal not displayed */
}

type CryptoReplaceFfxFpeConfig_CustomAlphabet struct {
	CustomAlphabet string `protobuf:"bytes,5,opt,name=custom_alphabet,json=customAlphabet,oneof"`
}

type CryptoReplaceFfxFpeConfig_FfxCommonNativeAlphabet int32

type CryptoReplaceFfxFpeConfig_Radix struct {
	Radix int32 `protobuf:"varint,6,opt,name=radix,oneof"`
}

type CustomInfoType struct {
	// Info type configuration. All custom info types must have configurations
	// that do not conflict with built-in info types or other custom info types.
	InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
	// Types that are valid to be assigned to Type:
	//	*CustomInfoType_Dictionary_
	Type isCustomInfoType_Type `protobuf_oneof:"type"`
}

type CustomInfoType_Dictionary struct {
	// Types that are valid to be assigned to Source:
	//	*CustomInfoType_Dictionary_WordList_
	Source isCustomInfoType_Dictionary_Source `protobuf_oneof:"source"`
}

type CustomInfoType_Dictionary_ struct {
	Dictionary *CustomInfoType_Dictionary `protobuf:"bytes,2,opt,name=dictionary,oneof"`
}

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

type CustomInfoType_Dictionary_WordList_ struct {
	WordList *CustomInfoType_Dictionary_WordList `protobuf:"bytes,1,opt,name=word_list,json=wordList,oneof"`
}

type DatastoreKey struct {
	// Datastore entity key.
	EntityKey *Key `protobuf:"bytes,1,opt,name=entity_key,json=entityKey" json:"entity_key,omitempty"`
}

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

type DeidentificationSummary struct {
	// Total size in bytes that were transformed in some way.
	TransformedBytes int64 `protobuf:"varint,2,opt,name=transformed_bytes,json=transformedBytes" json:"transformed_bytes,omitempty"`
	// Transformations applied to the dataset.
	TransformationSummaries []*TransformationSummary `protobuf:"bytes,3,rep,name=transformation_summaries,json=transformationSummaries" json:"transformation_summaries,omitempty"`
}

type DeidentifyConfig struct {
	// Types that are valid to be assigned to Transformation:
	//	*DeidentifyConfig_InfoTypeTransformations
	//	*DeidentifyConfig_RecordTransformations
	Transformation isDeidentifyConfig_Transformation `protobuf_oneof:"transformation"`
}

type DeidentifyConfig_InfoTypeTransformations struct {
	InfoTypeTransformations *InfoTypeTransformations `protobuf:"bytes,1,opt,name=info_type_transformations,json=infoTypeTransformations,oneof"`
}

type DeidentifyConfig_RecordTransformations struct {
	RecordTransformations *RecordTransformations `protobuf:"bytes,2,opt,name=record_transformations,json=recordTransformations,oneof"`
}

type DeidentifyContentRequest struct {
	// Configuration for the de-identification of the list of content items.
	DeidentifyConfig *DeidentifyConfig `protobuf:"bytes,1,opt,name=deidentify_config,json=deidentifyConfig" json:"deidentify_config,omitempty"`
	// Configuration for the inspector.
	InspectConfig *InspectConfig `protobuf:"bytes,2,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
	// The list of items to inspect. Up to 100 are allowed per request.
	// All items will be treated as text/*.
	Items []*ContentItem `protobuf:"bytes,3,rep,name=items" json:"items,omitempty"`
}

type DeidentifyContentResponse struct {
	Items []*ContentItem `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
	// A review of the transformations that took place for each item.
	Summaries []*DeidentificationSummary `protobuf:"bytes,2,rep,name=summaries" json:"summaries,omitempty"`
}

type DlpServiceClient interface {
	// Finds potentially sensitive info in a list of strings.
	// This method has limits on input size, processing time, and output size.
	InspectContent(ctx context.Context, in *InspectContentRequest, opts ...grpc.CallOption) (*InspectContentResponse, error)
	// Redacts potentially sensitive info from a list of strings.
	// This method has limits on input size, processing time, and output size.
	RedactContent(ctx context.Context, in *RedactContentRequest, opts ...grpc.CallOption) (*RedactContentResponse, error)
	// De-identifies potentially sensitive info from a list of strings.
	// This method has limits on input size and output size.
	DeidentifyContent(ctx context.Context, in *DeidentifyContentRequest, opts ...grpc.CallOption) (*DeidentifyContentResponse, error)
	// Schedules a job scanning content in a Google Cloud Platform data
	// repository.
	CreateInspectOperation(ctx context.Context, in *CreateInspectOperationRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error)
	// Schedules a job to compute risk analysis metrics over content in a Google
	// Cloud Platform repository.
	AnalyzeDataSourceRisk(ctx context.Context, in *AnalyzeDataSourceRiskRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error)
	// Returns list of results for given inspect operation result set id.
	ListInspectFindings(ctx context.Context, in *ListInspectFindingsRequest, opts ...grpc.CallOption) (*ListInspectFindingsResponse, error)
	// Returns sensitive information types for given category.
	ListInfoTypes(ctx context.Context, in *ListInfoTypesRequest, opts ...grpc.CallOption) (*ListInfoTypesResponse, error)
	// Returns the list of root categories of sensitive information.
	ListRootCategories(ctx context.Context, in *ListRootCategoriesRequest, opts ...grpc.CallOption) (*ListRootCategoriesResponse, error)
}

type DlpServiceServer interface {
	// Finds potentially sensitive info in a list of strings.
	// This method has limits on input size, processing time, and output size.
	InspectContent(context.Context, *InspectContentRequest) (*InspectContentResponse, error)
	// Redacts potentially sensitive info from a list of strings.
	// This method has limits on input size, processing time, and output size.
	RedactContent(context.Context, *RedactContentRequest) (*RedactContentResponse, error)
	// De-identifies potentially sensitive info from a list of strings.
	// This method has limits on input size and output size.
	DeidentifyContent(context.Context, *DeidentifyContentRequest) (*DeidentifyContentResponse, error)
	// Schedules a job scanning content in a Google Cloud Platform data
	// repository.
	CreateInspectOperation(context.Context, *CreateInspectOperationRequest) (*google_longrunning.Operation, error)
	// Schedules a job to compute risk analysis metrics over content in a Google
	// Cloud Platform repository.
	AnalyzeDataSourceRisk(context.Context, *AnalyzeDataSourceRiskRequest) (*google_longrunning.Operation, error)
	// Returns list of results for given inspect operation result set id.
	ListInspectFindings(context.Context, *ListInspectFindingsRequest) (*ListInspectFindingsResponse, error)
	// Returns sensitive information types for given category.
	ListInfoTypes(context.Context, *ListInfoTypesRequest) (*ListInfoTypesResponse, error)
	// Returns the list of root categories of sensitive information.
	ListRootCategories(context.Context, *ListRootCategoriesRequest) (*ListRootCategoriesResponse, error)
}

type EntityId struct {
	// Composite key indicating which field contains the entity identifier.
	Field *FieldId `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
}

type FieldId struct {
	// Name describing the field.
	ColumnName string `protobuf:"bytes,1,opt,name=column_name,json=columnName" json:"column_name,omitempty"`
}

type FieldTransformation struct {
	// Input field(s) to apply the transformation to. [required]
	Fields []*FieldId `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty"`
	// Only apply the transformation if the condition evaluates to true for the
	// given `RecordCondition`. The conditions are allowed to reference fields
	// that are not used in the actual transformation. [optional]
	//
	// Example Use Cases:
	//
	// - Apply a different bucket transformation to an age column if the zip code
	// column for the same record is within a specific range.
	// - Redact a field if the date of birth field is greater than 85.
	Condition *RecordCondition `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
	// Transformation to apply. [required]
	//
	// Types that are valid to be assigned to Transformation:
	//	*FieldTransformation_PrimitiveTransformation
	//	*FieldTransformation_InfoTypeTransformations
	Transformation isFieldTransformation_Transformation `protobuf_oneof:"transformation"`
}

type FieldTransformation_InfoTypeTransformations struct {
	InfoTypeTransformations *InfoTypeTransformations `protobuf:"bytes,5,opt,name=info_type_transformations,json=infoTypeTransformations,oneof"`
}

type FieldTransformation_PrimitiveTransformation struct {
	PrimitiveTransformation *PrimitiveTransformation `protobuf:"bytes,4,opt,name=primitive_transformation,json=primitiveTransformation,oneof"`
}

type Finding struct {
	// The specific string that may be potentially sensitive info.
	Quote string `protobuf:"bytes,1,opt,name=quote" json:"quote,omitempty"`
	// The specific type of info the string might be.
	InfoType *InfoType `protobuf:"bytes,2,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
	// Estimate of how likely it is that the info_type is correct.
	Likelihood Likelihood `protobuf:"varint,3,opt,name=likelihood,enum=google.privacy.dlp.v2beta1.Likelihood" json:"likelihood,omitempty"`
	// Location of the info found.
	Location *Location `protobuf:"bytes,4,opt,name=location" json:"location,omitempty"`
	// Timestamp when finding was detected.
	CreateTime *google_protobuf3.Timestamp `protobuf:"bytes,6,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
}

type FixedSizeBucketingConfig struct {
	// Lower bound value of buckets. All values less than `lower_bound` are
	// grouped together into a single bucket; for example if `lower_bound` = 10,
	// then all values less than 10 are replaced with the value “-10”. [Required].
	LowerBound *Value `protobuf:"bytes,1,opt,name=lower_bound,json=lowerBound" json:"lower_bound,omitempty"`
	// Upper bound value of buckets. All values greater than upper_bound are
	// grouped together into a single bucket; for example if `upper_bound` = 89,
	// then all values greater than 89 are replaced with the value “89+”.
	// [Required].
	UpperBound *Value `protobuf:"bytes,2,opt,name=upper_bound,json=upperBound" json:"upper_bound,omitempty"`
	// Size of each bucket (except for minimum and maximum buckets). So if
	// `lower_bound` = 10, `upper_bound` = 89, and `bucket_size` = 10, then the
	// following buckets would be used: -10, 10-20, 20-30, 30-40, 40-50, 50-60,
	// 60-70, 70-80, 80-89, 89+. Precision up to 2 decimals works. [Required].
	BucketSize float64 `protobuf:"fixed64,3,opt,name=bucket_size,json=bucketSize" json:"bucket_size,omitempty"`
}

type ImageLocation struct {
	// Top coordinate of the bounding box. (0,0) is upper left.
	Top int32 `protobuf:"varint,1,opt,name=top" json:"top,omitempty"`
	// Left coordinate of the bounding box. (0,0) is upper left.
	Left int32 `protobuf:"varint,2,opt,name=left" json:"left,omitempty"`
	// Width of the bounding box in pixels.
	Width int32 `protobuf:"varint,3,opt,name=width" json:"width,omitempty"`
	// Height of the bounding box in pixels.
	Height int32 `protobuf:"varint,4,opt,name=height" json:"height,omitempty"`
}

type InfoType struct {
	// Name of the information type.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

type InfoTypeDescription struct {
	// Internal name of the infoType.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Human readable form of the infoType name.
	DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
	// List of categories this infoType belongs to.
	Categories []*CategoryDescription `protobuf:"bytes,3,rep,name=categories" json:"categories,omitempty"`
}

type InfoTypeStatistics struct {
	// The type of finding this stat is for.
	InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
	// Number of findings for this info type.
	Count int64 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
}

type InfoTypeTransformations struct {
	// Transformation for each info type. Cannot specify more than one
	// for a given info type. [required]
	Transformations []*InfoTypeTransformations_InfoTypeTransformation `protobuf:"bytes,1,rep,name=transformations" json:"transformations,omitempty"`
}

type InfoTypeTransformations_InfoTypeTransformation struct {
	// Info types to apply the transformation to. Empty list will match all
	// available info types for this transformation.
	InfoTypes []*InfoType `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"`
	// Primitive transformation to apply to the info type. [required]
	PrimitiveTransformation *PrimitiveTransformation `protobuf:"bytes,2,opt,name=primitive_transformation,json=primitiveTransformation" json:"primitive_transformation,omitempty"`
}

type InspectConfig struct {
	// Restricts what info_types to look for. The values must correspond to
	// InfoType values returned by ListInfoTypes or found in documentation.
	// Empty info_types runs all enabled detectors.
	InfoTypes []*InfoType `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"`
	// Only returns findings equal or above this threshold.
	MinLikelihood Likelihood `` /* 137-byte string literal not displayed */
	// Limits the number of findings per content item or long running operation.
	MaxFindings int32 `protobuf:"varint,3,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"`
	// When true, a contextual quote from the data that triggered a finding is
	// included in the response; see Finding.quote.
	IncludeQuote bool `protobuf:"varint,4,opt,name=include_quote,json=includeQuote" json:"include_quote,omitempty"`
	// When true, excludes type information of the findings.
	ExcludeTypes bool `protobuf:"varint,6,opt,name=exclude_types,json=excludeTypes" json:"exclude_types,omitempty"`
	// Configuration of findings limit given for specified info types.
	InfoTypeLimits []*InspectConfig_InfoTypeLimit `protobuf:"bytes,7,rep,name=info_type_limits,json=infoTypeLimits" json:"info_type_limits,omitempty"`
	// Custom info types provided by the user.
	CustomInfoTypes []*CustomInfoType `protobuf:"bytes,8,rep,name=custom_info_types,json=customInfoTypes" json:"custom_info_types,omitempty"`
}

type InspectConfig_InfoTypeLimit struct {
	// Type of information the findings limit applies to. Only one limit per
	// info_type should be provided. If InfoTypeLimit does not have an
	// info_type, the DLP API applies the limit against all info_types that are
	// found but not specified in another InfoTypeLimit.
	InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"`
	// Max findings limit for the given infoType.
	MaxFindings int32 `protobuf:"varint,2,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"`
}

type InspectContentRequest struct {
	// Configuration for the inspector.
	InspectConfig *InspectConfig `protobuf:"bytes,1,opt,name=inspect_config,json=inspectConfig" json:"inspect_config,omitempty"`
	// The list of items to inspect. Items in a single request are
	// considered "related" unless inspect_config.independent_inputs is true.
	// Up to 100 are allowed per request.
	Items []*ContentItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
}

type InspectContentResponse struct {
	// Each content_item from the request has a result in this list, in the
	// same order as the request.
	Results []*InspectResult `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"`
}

type InspectOperationMetadata struct {
	// Total size in bytes that were processed.
	ProcessedBytes int64 `protobuf:"varint,1,opt,name=processed_bytes,json=processedBytes" json:"processed_bytes,omitempty"`
	// Estimate of the number of bytes to process.
	TotalEstimatedBytes int64                 `protobuf:"varint,4,opt,name=total_estimated_bytes,json=totalEstimatedBytes" json:"total_estimated_bytes,omitempty"`
	InfoTypeStats       []*InfoTypeStatistics `protobuf:"bytes,2,rep,name=info_type_stats,json=infoTypeStats" json:"info_type_stats,omitempty"`
	// The time which this request was started.
	CreateTime *google_protobuf3.Timestamp `protobuf:"bytes,3,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
	// The inspect config used to create the Operation.
	RequestInspectConfig *InspectConfig `protobuf:"bytes,5,opt,name=request_inspect_config,json=requestInspectConfig" json:"request_inspect_config,omitempty"`
	// The storage config used to create the Operation.
	RequestStorageConfig *StorageConfig `protobuf:"bytes,6,opt,name=request_storage_config,json=requestStorageConfig" json:"request_storage_config,omitempty"`
	// Optional location to store findings.
	RequestOutputConfig *OutputStorageConfig `protobuf:"bytes,7,opt,name=request_output_config,json=requestOutputConfig" json:"request_output_config,omitempty"`
}

type InspectOperationResult struct {
	// The server-assigned name, which is only unique within the same service that
	// originally returns it. If you use the default HTTP mapping, the
	// `name` should have the format of `inspect/results/{id}`.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

type InspectResult struct {
	// List of findings for an item.
	Findings []*Finding `protobuf:"bytes,1,rep,name=findings" json:"findings,omitempty"`
	// If true, then this item might have more findings than were returned,
	// and the findings returned are an arbitrary subset of all findings.
	// The findings list might be truncated because the input items were too
	// large, or because the server reached the maximum amount of resources
	// allowed for a single API call. For best results, divide the input into
	// smaller batches.
	FindingsTruncated bool `protobuf:"varint,2,opt,name=findings_truncated,json=findingsTruncated" json:"findings_truncated,omitempty"`
}

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

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

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

type KindExpression struct {
	// The name of the kind.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

type KmsWrappedCryptoKey struct {
	// The wrapped data crypto key. [required]
	WrappedKey []byte `protobuf:"bytes,1,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty"`
	// The resource name of the KMS CryptoKey to use for unwrapping. [required]
	CryptoKeyName string `protobuf:"bytes,2,opt,name=crypto_key_name,json=cryptoKeyName" json:"crypto_key_name,omitempty"`
}

type Likelihood int32

type ListInfoTypesRequest struct {
	// Category name as returned by ListRootCategories.
	Category string `protobuf:"bytes,1,opt,name=category" json:"category,omitempty"`
	// Optional BCP-47 language code for localized info type friendly
	// names. If omitted, or if localized strings are not available,
	// en-US strings will be returned.
	LanguageCode string `protobuf:"bytes,2,opt,name=language_code,json=languageCode" json:"language_code,omitempty"`
}

type ListInfoTypesResponse struct {
	// Set of sensitive info types belonging to a category.
	InfoTypes []*InfoTypeDescription `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"`
}

type ListInspectFindingsRequest struct {
	// Identifier of the results set returned as metadata of
	// the longrunning operation created by a call to InspectDataSource.
	// Should be in the format of `inspect/results/{id}`.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// Maximum number of results to return.
	// If 0, the implementation selects a reasonable value.
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
	// The value returned by the last `ListInspectFindingsResponse`; indicates
	// that this is a continuation of a prior `ListInspectFindings` call, and that
	// the system should return the next page of data.
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
	// Restricts findings to items that match. Supports info_type and likelihood.
	//
	// Examples:
	//
	// - info_type=EMAIL_ADDRESS
	// - info_type=PHONE_NUMBER,EMAIL_ADDRESS
	// - likelihood=VERY_LIKELY
	// - likelihood=VERY_LIKELY,LIKELY
	// - info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY
	Filter string `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"`
}

type ListInspectFindingsResponse struct {
	// The results.
	Result *InspectResult `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
	// If not empty, indicates that there may be more results that match the
	// request; this value should be passed in a new `ListInspectFindingsRequest`.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
}

type ListRootCategoriesRequest struct {
	// Optional language code for localized friendly category names.
	// If omitted or if localized strings are not available,
	// en-US strings will be returned.
	LanguageCode string `protobuf:"bytes,1,opt,name=language_code,json=languageCode" json:"language_code,omitempty"`
}

type ListRootCategoriesResponse struct {
	// List of all into type categories supported by the API.
	Categories []*CategoryDescription `protobuf:"bytes,1,rep,name=categories" json:"categories,omitempty"`
}

type Location struct {
	// Zero-based byte offsets within a content item.
	ByteRange *Range `protobuf:"bytes,1,opt,name=byte_range,json=byteRange" json:"byte_range,omitempty"`
	// Character offsets within a content item, included when content type
	// is a text. Default charset assumed to be UTF-8.
	CodepointRange *Range `protobuf:"bytes,2,opt,name=codepoint_range,json=codepointRange" json:"codepoint_range,omitempty"`
	// Location within an image's pixels.
	ImageBoxes []*ImageLocation `protobuf:"bytes,3,rep,name=image_boxes,json=imageBoxes" json:"image_boxes,omitempty"`
	// Key of the finding.
	RecordKey *RecordKey `protobuf:"bytes,4,opt,name=record_key,json=recordKey" json:"record_key,omitempty"`
	// Field id of the field containing the finding.
	FieldId *FieldId `protobuf:"bytes,5,opt,name=field_id,json=fieldId" json:"field_id,omitempty"`
	// Location within a `ContentItem.Table`.
	TableLocation *TableLocation `protobuf:"bytes,6,opt,name=table_location,json=tableLocation" json:"table_location,omitempty"`
}

type OperationConfig struct {
	// Max number of findings per file, Datastore entity, or database row.
	MaxItemFindings int64 `protobuf:"varint,1,opt,name=max_item_findings,json=maxItemFindings" json:"max_item_findings,omitempty"`
}

type OutputStorageConfig struct {
	// Types that are valid to be assigned to Type:
	//	*OutputStorageConfig_Table
	//	*OutputStorageConfig_StoragePath
	Type isOutputStorageConfig_Type `protobuf_oneof:"type"`
}

type OutputStorageConfig_StoragePath struct {
	StoragePath *CloudStoragePath `protobuf:"bytes,2,opt,name=storage_path,json=storagePath,oneof"`
}

type OutputStorageConfig_Table struct {
	Table *BigQueryTable `protobuf:"bytes,1,opt,name=table,oneof"`
}

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

type PrimitiveTransformation struct {
	// Types that are valid to be assigned to Transformation:
	//	*PrimitiveTransformation_ReplaceConfig
	//	*PrimitiveTransformation_RedactConfig
	//	*PrimitiveTransformation_CharacterMaskConfig
	//	*PrimitiveTransformation_CryptoReplaceFfxFpeConfig
	//	*PrimitiveTransformation_FixedSizeBucketingConfig
	//	*PrimitiveTransformation_BucketingConfig
	//	*PrimitiveTransformation_ReplaceWithInfoTypeConfig
	//	*PrimitiveTransformation_TimePartConfig
	//	*PrimitiveTransformation_CryptoHashConfig
	Transformation isPrimitiveTransformation_Transformation `protobuf_oneof:"transformation"`
}

type PrimitiveTransformation_BucketingConfig struct {
	BucketingConfig *BucketingConfig `protobuf:"bytes,6,opt,name=bucketing_config,json=bucketingConfig,oneof"`
}

type PrimitiveTransformation_CharacterMaskConfig struct {
	CharacterMaskConfig *CharacterMaskConfig `protobuf:"bytes,3,opt,name=character_mask_config,json=characterMaskConfig,oneof"`
}