--- title: "POST /v2/{+parent}/content:deidentify" method: POST path: "/v2/{+parent}/content:deidentify" tags: ["projects"] --- # POST /v2/{+parent}/content:deidentify `POST /v2/{+parent}/content:deidentify` De-identifies potentially sensitive info from a ContentItem. This method has limits on input size and output size. See https://cloud.google.com/sensitive-data-protection/docs/deidentify-sensitive-data to learn more. When no InfoTypes or CustomInfoTypes are specified in this request, the system will automatically choose what detectors to run. By default this may be all types, but may change over time as detectors are updated. ## Path parameters - `parent` string, required ## Request body - GooglePrivacyDlpV2DeidentifyContentRequest — Request to de-identify a ContentItem. - `deidentifyTemplateName` string — Template to use. Any configuration directly specified in deidentify_config will override those set in the template. Singular fields that are set in this request will replace their corresponding fields in the template. Repeated fields are appended. Singular sub-messages and groups are recursively merged. - `inspectTemplateName` string — Template to use. Any configuration directly specified in inspect_config will override those set in the template. Singular fields that are set in this request will replace their corresponding fields in the template. Repeated fields are appended. Singular sub-messages and groups are recursively merged. - `item` GooglePrivacyDlpV2ContentItem — Type of content to inspect. - `batchContentItem` GooglePrivacyDlpV2BatchContentItem — Represents a batch of content to inspect or redact. - `stringValueBatch` GooglePrivacyDlpV2StringValueBatch — Represents a batch of string values to inspect or redact. - `values` string[] — Optional. Represents string data to inspect or redact. - `value` string — String data to inspect or redact. - `conversation` GooglePrivacyDlpV2Conversation — Complete conversation or slice of a conversation. It is assumed that all included messages are contiguous and ordered in chronological order. - `messages` GooglePrivacyDlpV2ConversationMessage[] — Messages exchanged within this conversation. The maximum number of messages allowed is 50k. The order of the messages is assumed to be chronological and will be used to index findings in the response. - `content` string — The contents of this message. - `messageType` 'MESSAGE_TYPE_UNSPECIFIED' | 'CONTENT' | 'CONTEXT' — The type of message. - `participantId` string — Optional. The identifier of the participant, for example 'test-user' or 'gemini'. The participant ID can contain lowercase letters, numbers, and hyphens; that is, it must match the regular expression: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`. The maximum length is 63 characters. - `byteItem` GooglePrivacyDlpV2ByteContentItem — Container for bytes to inspect or redact. - `type` 'BYTES_TYPE_UNSPECIFIED' | 'IMAGE' | 'IMAGE_JPEG' | 'IMAGE_BMP' | 'IMAGE_PNG' | 'IMAGE_SVG' | 'TEXT_UTF8' | 'WORD_DOCUMENT' | 'PDF' | 'POWERPOINT_DOCUMENT' | 'EXCEL_DOCUMENT' | 'AVRO' | 'CSV' | 'TSV' | 'AUDIO' | 'VIDEO' | 'EXECUTABLE' | 'AI_MODEL' — The type of data stored in the bytes string. Default will be TEXT_UTF8. - `data` string, byte — Content data to inspect or redact. - `table` GooglePrivacyDlpV2Table — Structured content to inspect. Up to 50,000 `Value`s per request allowed. See https://cloud.google.com/sensitive-data-protection/docs/inspecting-structured-text#inspecting_a_table to learn more. - `headers` GooglePrivacyDlpV2FieldId[] — Headers of the table. - `name` string — Name describing the field. - `rows` GooglePrivacyDlpV2Row[] — Rows of the table. - `values` GooglePrivacyDlpV2Value[] — Individual cells. - `dayOfWeekValue` 'DAY_OF_WEEK_UNSPECIFIED' | 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY' — day of week - `integerValue` string, int64 — integer - `floatValue` number, double — float - `timestampValue` string, google-datetime — timestamp - `dateValue` GoogleTypeDate — Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp - `month` integer — Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day. - `day` integer — Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant. - `year` integer — Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year. - `stringValue` string — string - `booleanValue` boolean — boolean - `timeValue` GoogleTypeTimeOfDay — Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. - `hours` integer — Hours of a day in 24 hour format. Must be greater than or equal to 0 and typically must be less than or equal to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time. - `seconds` integer — Seconds of a minute. Must be greater than or equal to 0 and typically must be less than or equal to 59. An API may allow the value 60 if it allows leap-seconds. - `minutes` integer — Minutes of an hour. Must be greater than or equal to 0 and less than or equal to 59. - `nanos` integer — Fractions of seconds, in nanoseconds. Must be greater than or equal to 0 and less than or equal to 999,999,999. - `contentMetadata` GooglePrivacyDlpV2ContentMetadata — Metadata on content to be scanned. - `properties` GooglePrivacyDlpV2KeyValueMetadataProperty[] — User provided key-value pairs of content metadata. - `value` string — The value of the property. - `key` string — The key of the property. - `fileLabels` GooglePrivacyDlpV2FileLabel[] — Optional. The file labels associated with the content. - `sensitivityLabel` GooglePrivacyDlpV2SensitivityLabelMetadata — Sensitivity labels published by Microsoft. - `guid` string — Required. The GUID of the sensitivity label. - `googleDriveLabel` GooglePrivacyDlpV2GoogleDriveLabelMetadata — Google Drive labels published by Google. - `labelId` string — The [label ID](https://developers.google.com/workspace/drive/labels/guides/overview) of the Google Drive label. - `labelFields` GooglePrivacyDlpV2LabelFieldMetadata[] — The field values of the Google Drive label - `id` string — The identifier of the Label Field. - `value` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `locationId` string — Deprecated. This field has no effect. - `deidentifyConfig` GooglePrivacyDlpV2DeidentifyConfig — The configuration that controls how the data will change. - `infoTypeTransformations` GooglePrivacyDlpV2InfoTypeTransformations — A type of transformation that will scan unstructured text and apply various `PrimitiveTransformation`s to each finding, where the transformation is applied to only values that were identified as a specific info_type. - `transformations` GooglePrivacyDlpV2InfoTypeTransformation[] — Required. Transformation for each infoType. Cannot specify more than one for a given infoType. - `primitiveTransformation` GooglePrivacyDlpV2PrimitiveTransformation — A rule for transforming a value. - `redactConfig` GooglePrivacyDlpV2RedactConfig — Redact a given value. For example, if used with an `InfoTypeTransformation` transforming PHONE_NUMBER, and input 'My phone number is 206-555-0123', the output would be 'My phone number is '. - `bucketingConfig` GooglePrivacyDlpV2BucketingConfig — Generalization function that buckets values based on ranges. The ranges and replacement values are dynamically provided by the user for custom behavior, such as 1-30 -> LOW, 31-65 -> MEDIUM, 66-100 -> HIGH. This can be used on data of type: number, long, string, timestamp. If the bound `Value` type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing. See https://cloud.google.com/sensitive-data-protection/docs/concepts-bucketing to learn more. - `buckets` GooglePrivacyDlpV2Bucket[] — Set of buckets. Ranges must be non-overlapping. - … - `cryptoHashConfig` GooglePrivacyDlpV2CryptoHashConfig — Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. The key size must be either 32 or 64 bytes. Outputs a base64 encoded representation of the hashed output (for example, L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=). Currently, only string and integer values can be hashed. See https://cloud.google.com/sensitive-data-protection/docs/pseudonymization to learn more. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `timePartConfig` GooglePrivacyDlpV2TimePartConfig — For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. - `partToExtract` 'TIME_PART_UNSPECIFIED' | 'YEAR' | 'MONTH' | 'DAY_OF_MONTH' | 'DAY_OF_WEEK' | 'WEEK_OF_YEAR' | 'HOUR_OF_DAY' — The part of the time to keep. - `dateShiftConfig` GooglePrivacyDlpV2DateShiftConfig — Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/sensitive-data-protection/docs/concepts-date-shifting to learn more. - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `upperBoundDays` integer — Required. Range of shift in days. Actual shift will be selected at random within this range (inclusive ends). Negative means shift to earlier in time. Must not be more than 365250 days (1000 years) each direction. For example, 3 means shift date to at most 3 days into the future. - `lowerBoundDays` integer — Required. For example, -5 means shift date to at most 5 days back in the past. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `replaceDictionaryConfig` GooglePrivacyDlpV2ReplaceDictionaryConfig — Replace each input value with a value randomly selected from the dictionary. - `wordList` GooglePrivacyDlpV2WordList — Message defining a list of words or phrases to search for in the data. - … - `cryptoReplaceFfxFpeConfig` GooglePrivacyDlpV2CryptoReplaceFfxFpeConfig — Replaces an identifier with a surrogate using Format Preserving Encryption (FPE) with the FFX mode of operation; however when used in the `ReidentifyContent` API method, it serves the opposite function by reversing the surrogate back into the original identifier. The identifier must be encoded as ASCII. For a given crypto key and context, the same identifier will be replaced with the same surrogate. Identifiers must be at least two characters long. In the case that the identifier is the empty string, it will be skipped. See https://cloud.google.com/sensitive-data-protection/docs/pseudonymization to learn more. Note: We recommend using CryptoDeterministicConfig for all use cases which do not require preserving the input alphabet space and size, plus warrant referential integrity. FPE incurs significant latency costs. - `customAlphabet` string — This is supported by mapping these to the alphanumeric characters that the FFX mode natively supports. This happens before/after encryption/decryption. Each character listed must appear only once. Number of characters must be in the range [2, 95]. This must be encoded as ASCII. The order of characters does not matter. The full list of allowed characters is: ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/`` - `radix` integer — The native way to select the alphabet. Must be in the range [2, 95]. - `surrogateInfoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - … - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `commonAlphabet` 'FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED' | 'NUMERIC' | 'HEXADECIMAL' | 'UPPER_CASE_ALPHA_NUMERIC' | 'ALPHA_NUMERIC' — Common alphabets. - `replaceWithInfoTypeConfig` GooglePrivacyDlpV2ReplaceWithInfoTypeConfig — Replace each matching finding with the name of the info_type. - `characterMaskConfig` GooglePrivacyDlpV2CharacterMaskConfig — Partially mask a string by replacing a given number of characters with a fixed character. Masking can start from the beginning or end of the string. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3. - `maskingCharacter` string — Character to use to mask the sensitive values—for example, `*` for an alphabetic string such as a name, or `0` for a numeric string such as ZIP code or credit card number. This string must have a length of 1. If not supplied, this value defaults to `*` for strings, and `0` for digits. - `reverseOrder` boolean — Mask characters in reverse order. For example, if `masking_character` is `0`, `number_to_mask` is `14`, and `reverse_order` is `false`, then the input string `1234-5678-9012-3456` is masked as `00000000000000-3456`. If `masking_character` is `*`, `number_to_mask` is `3`, and `reverse_order` is `true`, then the string `12345` is masked as `12***`. - `charactersToIgnore` GooglePrivacyDlpV2CharsToIgnore[] — When masking a string, items in this list will be skipped when replacing characters. For example, if the input string is `555-555-5555` and you instruct Cloud DLP to skip `-` and mask 5 characters with `*`, Cloud DLP returns `***-**5-5555`. - … - `numberToMask` integer — Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally. If `number_to_mask` is negative, this denotes inverse masking. Cloud DLP masks all but a number of characters. For example, suppose you have the following values: - `masking_character` is `*` - `number_to_mask` is `-4` - `reverse_order` is `false` - `CharsToIgnore` includes `-` - Input string is `1234-5678-9012-3456` The resulting de-identified string is `****-****-****-3456`. Cloud DLP masks all but the last four characters. If `reverse_order` is `true`, all but the first four characters are masked as `1234-****-****-****`. - `fixedSizeBucketingConfig` GooglePrivacyDlpV2FixedSizeBucketingConfig — Buckets values based on fixed size ranges. The Bucketing transformation can provide all of this functionality, but requires more configuration. This message is provided as a convenience to the user for simple bucketing strategies. The transformed value will be a hyphenated string of {lower_bound}-{upper_bound}. For example, if lower_bound = 10 and upper_bound = 20, all values that are within this bucket will be replaced with "10-20". This can be used on data of type: double, long. If the bound Value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing. See https://cloud.google.com/sensitive-data-protection/docs/concepts-bucketing to learn more. - `bucketSize` number, double — Required. 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. - `lowerBound` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `upperBound` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `replaceConfig` GooglePrivacyDlpV2ReplaceValueConfig — Replace each input value with a given `Value`. - `newValue` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `cryptoDeterministicConfig` GooglePrivacyDlpV2CryptoDeterministicConfig — Pseudonymization method that generates deterministic encryption for the given input. Outputs a base64 encoded representation of the encrypted output. Uses AES-SIV based on the RFC https://tools.ietf.org/html/rfc5297. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `surrogateInfoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - … - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `infoTypes` GooglePrivacyDlpV2InfoType[] — InfoTypes to apply the transformation to. An empty list will cause this transformation to apply to all findings that correspond to infoTypes that were requested in `InspectConfig`. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. - `recordTransformations` GooglePrivacyDlpV2RecordTransformations — A type of transformation that is applied over structured data such as a table. - `fieldTransformations` GooglePrivacyDlpV2FieldTransformation[] — Transform the record by applying various field transformations. - `fields` GooglePrivacyDlpV2FieldId[] — Required. Input field(s) to apply the transformation to. When you have columns that reference their position within a list, omit the index from the FieldId. FieldId name matching ignores the index. For example, instead of "contact.nums[0].type", use "contact.nums.type". - `name` string — Name describing the field. - `infoTypeTransformations` GooglePrivacyDlpV2InfoTypeTransformations — A type of transformation that will scan unstructured text and apply various `PrimitiveTransformation`s to each finding, where the transformation is applied to only values that were identified as a specific info_type. - `transformations` GooglePrivacyDlpV2InfoTypeTransformation[] — Required. Transformation for each infoType. Cannot specify more than one for a given infoType. - `primitiveTransformation` GooglePrivacyDlpV2PrimitiveTransformation — A rule for transforming a value. - … - `infoTypes` GooglePrivacyDlpV2InfoType[] — InfoTypes to apply the transformation to. An empty list will cause this transformation to apply to all findings that correspond to infoTypes that were requested in `InspectConfig`. - … - `primitiveTransformation` GooglePrivacyDlpV2PrimitiveTransformation — A rule for transforming a value. - `redactConfig` GooglePrivacyDlpV2RedactConfig — Redact a given value. For example, if used with an `InfoTypeTransformation` transforming PHONE_NUMBER, and input 'My phone number is 206-555-0123', the output would be 'My phone number is '. - `bucketingConfig` GooglePrivacyDlpV2BucketingConfig — Generalization function that buckets values based on ranges. The ranges and replacement values are dynamically provided by the user for custom behavior, such as 1-30 -> LOW, 31-65 -> MEDIUM, 66-100 -> HIGH. This can be used on data of type: number, long, string, timestamp. If the bound `Value` type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing. See https://cloud.google.com/sensitive-data-protection/docs/concepts-bucketing to learn more. - `buckets` GooglePrivacyDlpV2Bucket[] — Set of buckets. Ranges must be non-overlapping. - … - `cryptoHashConfig` GooglePrivacyDlpV2CryptoHashConfig — Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. The key size must be either 32 or 64 bytes. Outputs a base64 encoded representation of the hashed output (for example, L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=). Currently, only string and integer values can be hashed. See https://cloud.google.com/sensitive-data-protection/docs/pseudonymization to learn more. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `timePartConfig` GooglePrivacyDlpV2TimePartConfig — For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. - `partToExtract` 'TIME_PART_UNSPECIFIED' | 'YEAR' | 'MONTH' | 'DAY_OF_MONTH' | 'DAY_OF_WEEK' | 'WEEK_OF_YEAR' | 'HOUR_OF_DAY' — The part of the time to keep. - `dateShiftConfig` GooglePrivacyDlpV2DateShiftConfig — Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/sensitive-data-protection/docs/concepts-date-shifting to learn more. - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `upperBoundDays` integer — Required. Range of shift in days. Actual shift will be selected at random within this range (inclusive ends). Negative means shift to earlier in time. Must not be more than 365250 days (1000 years) each direction. For example, 3 means shift date to at most 3 days into the future. - `lowerBoundDays` integer — Required. For example, -5 means shift date to at most 5 days back in the past. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `replaceDictionaryConfig` GooglePrivacyDlpV2ReplaceDictionaryConfig — Replace each input value with a value randomly selected from the dictionary. - `wordList` GooglePrivacyDlpV2WordList — Message defining a list of words or phrases to search for in the data. - … - `cryptoReplaceFfxFpeConfig` GooglePrivacyDlpV2CryptoReplaceFfxFpeConfig — Replaces an identifier with a surrogate using Format Preserving Encryption (FPE) with the FFX mode of operation; however when used in the `ReidentifyContent` API method, it serves the opposite function by reversing the surrogate back into the original identifier. The identifier must be encoded as ASCII. For a given crypto key and context, the same identifier will be replaced with the same surrogate. Identifiers must be at least two characters long. In the case that the identifier is the empty string, it will be skipped. See https://cloud.google.com/sensitive-data-protection/docs/pseudonymization to learn more. Note: We recommend using CryptoDeterministicConfig for all use cases which do not require preserving the input alphabet space and size, plus warrant referential integrity. FPE incurs significant latency costs. - `customAlphabet` string — This is supported by mapping these to the alphanumeric characters that the FFX mode natively supports. This happens before/after encryption/decryption. Each character listed must appear only once. Number of characters must be in the range [2, 95]. This must be encoded as ASCII. The order of characters does not matter. The full list of allowed characters is: ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/`` - `radix` integer — The native way to select the alphabet. Must be in the range [2, 95]. - `surrogateInfoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - … - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `commonAlphabet` 'FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED' | 'NUMERIC' | 'HEXADECIMAL' | 'UPPER_CASE_ALPHA_NUMERIC' | 'ALPHA_NUMERIC' — Common alphabets. - `replaceWithInfoTypeConfig` GooglePrivacyDlpV2ReplaceWithInfoTypeConfig — Replace each matching finding with the name of the info_type. - `characterMaskConfig` GooglePrivacyDlpV2CharacterMaskConfig — Partially mask a string by replacing a given number of characters with a fixed character. Masking can start from the beginning or end of the string. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3. - `maskingCharacter` string — Character to use to mask the sensitive values—for example, `*` for an alphabetic string such as a name, or `0` for a numeric string such as ZIP code or credit card number. This string must have a length of 1. If not supplied, this value defaults to `*` for strings, and `0` for digits. - `reverseOrder` boolean — Mask characters in reverse order. For example, if `masking_character` is `0`, `number_to_mask` is `14`, and `reverse_order` is `false`, then the input string `1234-5678-9012-3456` is masked as `00000000000000-3456`. If `masking_character` is `*`, `number_to_mask` is `3`, and `reverse_order` is `true`, then the string `12345` is masked as `12***`. - `charactersToIgnore` GooglePrivacyDlpV2CharsToIgnore[] — When masking a string, items in this list will be skipped when replacing characters. For example, if the input string is `555-555-5555` and you instruct Cloud DLP to skip `-` and mask 5 characters with `*`, Cloud DLP returns `***-**5-5555`. - … - `numberToMask` integer — Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally. If `number_to_mask` is negative, this denotes inverse masking. Cloud DLP masks all but a number of characters. For example, suppose you have the following values: - `masking_character` is `*` - `number_to_mask` is `-4` - `reverse_order` is `false` - `CharsToIgnore` includes `-` - Input string is `1234-5678-9012-3456` The resulting de-identified string is `****-****-****-3456`. Cloud DLP masks all but the last four characters. If `reverse_order` is `true`, all but the first four characters are masked as `1234-****-****-****`. - `fixedSizeBucketingConfig` GooglePrivacyDlpV2FixedSizeBucketingConfig — Buckets values based on fixed size ranges. The Bucketing transformation can provide all of this functionality, but requires more configuration. This message is provided as a convenience to the user for simple bucketing strategies. The transformed value will be a hyphenated string of {lower_bound}-{upper_bound}. For example, if lower_bound = 10 and upper_bound = 20, all values that are within this bucket will be replaced with "10-20". This can be used on data of type: double, long. If the bound Value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing. See https://cloud.google.com/sensitive-data-protection/docs/concepts-bucketing to learn more. - `bucketSize` number, double — Required. 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. - `lowerBound` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `upperBound` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `replaceConfig` GooglePrivacyDlpV2ReplaceValueConfig — Replace each input value with a given `Value`. - `newValue` GooglePrivacyDlpV2Value — Set of primitive values supported by the system. Note that for the purposes of inspection or transformation, the number of bytes considered to comprise a 'Value' is based on its representation as a UTF-8 encoded string. For example, if 'integer_value' is set to 123456789, the number of bytes would be counted as 9, even though an int64 only holds up to 8 bytes of data. - … - `cryptoDeterministicConfig` GooglePrivacyDlpV2CryptoDeterministicConfig — Pseudonymization method that generates deterministic encryption for the given input. Outputs a base64 encoded representation of the encrypted output. Uses AES-SIV based on the RFC https://tools.ietf.org/html/rfc5297. - `cryptoKey` GooglePrivacyDlpV2CryptoKey — This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by Cloud Key Management Service (Cloud KMS). When using Cloud KMS to wrap or unwrap a DEK, be sure to set an appropriate IAM policy on the KEK to ensure an attacker cannot unwrap the DEK. - … - `surrogateInfoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - … - `context` GooglePrivacyDlpV2FieldId — General identifier of a data field in a storage service. - … - `condition` GooglePrivacyDlpV2RecordCondition — A condition for determining whether a transformation should be applied to a field. - `expressions` GooglePrivacyDlpV2Expressions — An expression, consisting of an operator and conditions. - `logicalOperator` 'LOGICAL_OPERATOR_UNSPECIFIED' | 'AND' — The operator to apply to the result of conditions. Default and currently only supported value is `AND`. - `conditions` GooglePrivacyDlpV2Conditions — A collection of conditions. - … - `recordSuppressions` GooglePrivacyDlpV2RecordSuppression[] — Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output. - `condition` GooglePrivacyDlpV2RecordCondition — A condition for determining whether a transformation should be applied to a field. - `expressions` GooglePrivacyDlpV2Expressions — An expression, consisting of an operator and conditions. - `logicalOperator` 'LOGICAL_OPERATOR_UNSPECIFIED' | 'AND' — The operator to apply to the result of conditions. Default and currently only supported value is `AND`. - `conditions` GooglePrivacyDlpV2Conditions — A collection of conditions. - … - `imageTransformations` GooglePrivacyDlpV2ImageTransformations — A type of transformation that is applied over images. - `transforms` GooglePrivacyDlpV2ImageTransformation[] — List of transforms to make. - `allInfoTypes` GooglePrivacyDlpV2AllInfoTypes — Apply transformation to all findings. - `allText` GooglePrivacyDlpV2AllText — Apply to all text. - `selectedInfoTypes` GooglePrivacyDlpV2SelectedInfoTypes — Apply transformation to the selected info_types. - `infoTypes` GooglePrivacyDlpV2InfoType[] — Required. InfoTypes to apply the transformation to. Required. Provided InfoType must be unique within the ImageTransformations message. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - … - `version` string — Optional version name for this InfoType. - `redactionColor` GooglePrivacyDlpV2Color — Represents a color in the RGB color space. - `blue` number, float — The amount of blue in the color as a value in the interval [0, 1]. - `red` number, float — The amount of red in the color as a value in the interval [0, 1]. - `green` number, float — The amount of green in the color as a value in the interval [0, 1]. - `transformationErrorHandling` GooglePrivacyDlpV2TransformationErrorHandling — How to handle transformation errors during de-identification. A transformation error occurs when the requested transformation is incompatible with the data. For example, trying to de-identify an IP address using a `DateShift` transformation would result in a transformation error, since date info cannot be extracted from an IP address. Information about any incompatible transformations, and how they were handled, is returned in the response as part of the `TransformationOverviews`. - `throwError` GooglePrivacyDlpV2ThrowError — Throw an error and fail the request when a transformation error occurs. - `leaveUntransformed` GooglePrivacyDlpV2LeaveUntransformed — Skips the data without modifying it if the requested transformation would cause an error. For example, if a `DateShift` transformation were applied an an IP address, this mode would leave the IP address unchanged in the response. - `inspectConfig` GooglePrivacyDlpV2InspectConfig — Configuration description of the scanning process. When used with redactContent only info_types and min_likelihood are currently used. - `minLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Only returns findings equal to or above this threshold. The default is POSSIBLE. In general, the highest likelihood setting yields the fewest findings in results and the lowest chance of a false positive. For more information, see [Match likelihood](https://cloud.google.com/sensitive-data-protection/docs/likelihood). - `limits` GooglePrivacyDlpV2FindingLimits — Configuration to control the number of findings returned for inspection. This is not used for de-identification or data profiling. When redacting sensitive data from images, finding limits don't apply. They can cause unexpected or inconsistent results, where only some data is redacted. Don't include finding limits in RedactImage requests. Otherwise, Cloud DLP returns an error. - `maxFindingsPerRequest` integer — Max number of findings that are returned per request or job. If you set this field in an InspectContentRequest, the resulting maximum value is the value that you set or 3,000, whichever is lower. This value isn't a hard limit. If an inspection reaches this limit, the inspection ends gradually, not abruptly. Therefore, the actual number of findings that Cloud DLP returns can be multiple times higher than this value. - `maxFindingsPerItem` integer — Max number of findings that are returned for each item scanned. When set within an InspectContentRequest, this field is ignored. This value isn't a hard limit. If the number of findings for an item reaches this limit, the inspection of that item ends gradually, not abruptly. Therefore, the actual number of findings that Cloud DLP returns for the item can be multiple times higher than this value. - `maxFindingsPerInfoType` GooglePrivacyDlpV2InfoTypeLimit[] — Configuration of findings limit given for specified infoTypes. - `infoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. - `maxFindings` integer — Max findings limit for the given infoType. - `minLikelihoodPerInfoType` GooglePrivacyDlpV2InfoTypeLikelihood[] — Minimum likelihood per infotype. For each infotype, a user can specify a minimum likelihood. The system only returns a finding if its likelihood is above this threshold. If this field is not set, the system uses the InspectConfig min_likelihood. - `infoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. - `minLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Only returns findings equal to or above this threshold. This field is required or else the configuration fails. - `customInfoTypes` GooglePrivacyDlpV2CustomInfoType[] — CustomInfoTypes provided by the user. See https://cloud.google.com/sensitive-data-protection/docs/creating-custom-infotypes to learn more. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `detectionRules` GooglePrivacyDlpV2DetectionRule[] — Set of detection rules to apply to all findings of this CustomInfoType. Rules are applied in the order that they are specified. Only supported for the `dictionary`, `regex`, and `stored_type` CustomInfoTypes. - `hotwordRule` GooglePrivacyDlpV2HotwordRule — The rule that adjusts the likelihood of findings within a certain proximity of hotwords. - `hotwordRegex` GooglePrivacyDlpV2Regex — Message defining a custom regular expression. - `pattern` string — Pattern defining the regular expression. Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub. - `groupIndexes` integer[] — The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included. - `likelihoodAdjustment` GooglePrivacyDlpV2LikelihoodAdjustment — Message for specifying an adjustment to the likelihood of a finding as part of a detection rule. - `fixedLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Set the likelihood of a finding to a fixed value. - `relativeLikelihood` integer — Increase or decrease the likelihood by the specified number of levels. For example, if a finding would be `POSSIBLE` without the detection rule and `relative_likelihood` is 1, then it is upgraded to `LIKELY`, while a value of -1 would downgrade it to `UNLIKELY`. Likelihood may never drop below `VERY_UNLIKELY` or exceed `VERY_LIKELY`, so applying an adjustment of 1 followed by an adjustment of -1 when base likelihood is `VERY_LIKELY` will result in a final likelihood of `LIKELY`. - `proximity` GooglePrivacyDlpV2Proximity — Message for specifying a window around a finding to apply a detection rule. - `windowBefore` integer — Number of characters before the finding to consider. For tabular data, if you want to modify the likelihood of an entire column of findngs, set this to 1. For more information, see [Hotword example: Set the match likelihood of a table column] (https://cloud.google.com/sensitive-data-protection/docs/creating-custom-infotypes-likelihood#match-column-values). - `windowAfter` integer — Number of characters after the finding to consider. - `storedType` GooglePrivacyDlpV2StoredType — A reference to a StoredInfoType to use with scanning. - `name` string — Resource name of the requested `StoredInfoType`, for example `organizations/433245324/storedInfoTypes/432452342` or `projects/project-id/storedInfoTypes/432452342`. - `createTime` string, google-datetime — Timestamp indicating when the version of the `StoredInfoType` used for inspection was created. Output-only field, populated by the system. - `metadataKeyValueExpression` GooglePrivacyDlpV2MetadataKeyValueExpression — Configuration for a custom infoType that detects key-value pairs in the metadata matching the specified regular expressions. - `valueRegex` string — The regular expression for the value. Value should be non-empty. - `keyRegex` string — The regular expression for the key. Key should be non-empty. - `exclusionType` 'EXCLUSION_TYPE_UNSPECIFIED' | 'EXCLUSION_TYPE_EXCLUDE' — If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding to be returned. It still can be used for rules matching. Only supported for the `dictionary`, `regex`, and `stored_type` CustomInfoTypes. - `fileLabelInfoType` GooglePrivacyDlpV2FileLabelInfoType — Configuration for a custom infoType that detects file labels. - `googleDriveLabel` GooglePrivacyDlpV2GoogleDriveLabel — Google Drive labels published by Google. - `labelFieldsToMatch` GooglePrivacyDlpV2LabelField[] — The field values of the Google Drive label to match. - `id` string — The identifier of the Label Field. - `value` string — The value of the Label Field to match. - `labelId` string — The [label ID](https://developers.google.com/workspace/drive/labels/guides/overview) of the Google Drive label. - `sensitivityLabel` GooglePrivacyDlpV2SensitivityLabel — Sensitivity labels published by Microsoft. - `guid` string — The GUID of the sensitivity label. - `likelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Likelihood to return for this CustomInfoType. This base value can be altered by a detection rule if the finding meets the criteria specified by the rule. Defaults to `VERY_LIKELY` if not specified. - `infoType` GooglePrivacyDlpV2InfoType — Type of information detected by the API. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. - `dictionary` GooglePrivacyDlpV2Dictionary — Custom information type based on a dictionary of words or phrases. This can be used to match sensitive information specific to the data, such as a list of employee IDs or job titles. Dictionary words are case-insensitive and all characters other than letters and digits in the unicode [Basic Multilingual Plane](https://en.wikipedia.org/wiki/Plane_%28Unicode%29#Basic_Multilingual_Plane) will be replaced with whitespace when scanning for matches, so the dictionary phrase "Sam Johnson" will match all three phrases "sam johnson", "Sam, Johnson", and "Sam (Johnson)". Additionally, the characters surrounding any match must be of a different type than the adjacent characters within the word, so letters must be next to non-letters and digits next to non-digits. For example, the dictionary word "jen" will match the first three letters of the text "jen123" but will return no matches for "jennifer". Dictionary words containing a large number of characters that are not letters or digits may result in unexpected findings because such characters are treated as whitespace. The [limits](https://cloud.google.com/sensitive-data-protection/limits) page contains details about the size limits of dictionaries. For dictionaries that do not fit within these constraints, consider using `LargeCustomDictionaryConfig` in the `StoredInfoType` API. - `wordList` GooglePrivacyDlpV2WordList — Message defining a list of words or phrases to search for in the data. - `words` string[] — 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] - `cloudStoragePath` GooglePrivacyDlpV2CloudStoragePath — Message representing a single file or path in Cloud Storage. - `path` string — A URL representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt` - `regex` GooglePrivacyDlpV2Regex — Message defining a custom regular expression. - `pattern` string — Pattern defining the regular expression. Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub. - `groupIndexes` integer[] — The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included. - `surrogateType` GooglePrivacyDlpV2SurrogateType — Message for detecting output from deidentification transformations such as [`CryptoReplaceFfxFpeConfig`](https://cloud.google.com/sensitive-data-protection/docs/reference/rest/v2/organizations.deidentifyTemplates#cryptoreplaceffxfpeconfig). These types of transformations are those that perform pseudonymization, thereby producing a "surrogate" as output. This should be used in conjunction with a field on the transformation such as `surrogate_info_type`. This CustomInfoType does not support the use of `detection_rules`. - `ruleSet` GooglePrivacyDlpV2InspectionRuleSet[] — Set of rules to apply to the findings for this InspectConfig. Exclusion rules, contained in the set are executed in the end, other rules are executed in the order they are specified for each info type. Not supported for the `metadata_key_value_expression` CustomInfoType. - `infoTypes` GooglePrivacyDlpV2InfoType[] — List of infoTypes this rule set is applied to. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. - `rules` GooglePrivacyDlpV2InspectionRule[] — Set of rules to be applied to infoTypes. The rules are applied in order. - `exclusionRule` GooglePrivacyDlpV2ExclusionRule — The rule that specifies conditions when findings of infoTypes specified in `InspectionRuleSet` are removed from results. - `dictionary` GooglePrivacyDlpV2Dictionary — Custom information type based on a dictionary of words or phrases. This can be used to match sensitive information specific to the data, such as a list of employee IDs or job titles. Dictionary words are case-insensitive and all characters other than letters and digits in the unicode [Basic Multilingual Plane](https://en.wikipedia.org/wiki/Plane_%28Unicode%29#Basic_Multilingual_Plane) will be replaced with whitespace when scanning for matches, so the dictionary phrase "Sam Johnson" will match all three phrases "sam johnson", "Sam, Johnson", and "Sam (Johnson)". Additionally, the characters surrounding any match must be of a different type than the adjacent characters within the word, so letters must be next to non-letters and digits next to non-digits. For example, the dictionary word "jen" will match the first three letters of the text "jen123" but will return no matches for "jennifer". Dictionary words containing a large number of characters that are not letters or digits may result in unexpected findings because such characters are treated as whitespace. The [limits](https://cloud.google.com/sensitive-data-protection/limits) page contains details about the size limits of dictionaries. For dictionaries that do not fit within these constraints, consider using `LargeCustomDictionaryConfig` in the `StoredInfoType` API. - `wordList` GooglePrivacyDlpV2WordList — Message defining a list of words or phrases to search for in the data. - … - `cloudStoragePath` GooglePrivacyDlpV2CloudStoragePath — Message representing a single file or path in Cloud Storage. - … - `regex` GooglePrivacyDlpV2Regex — Message defining a custom regular expression. - `pattern` string — Pattern defining the regular expression. Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub. - `groupIndexes` integer[] — The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included. - `excludeInfoTypes` GooglePrivacyDlpV2ExcludeInfoTypes — List of excluded infoTypes. - `infoTypes` GooglePrivacyDlpV2InfoType[] — InfoType list in ExclusionRule rule drops a finding when it overlaps or contained within with a finding of an infoType from this list. For example, for `InspectionRuleSet.info_types` containing "PHONE_NUMBER"` and `exclusion_rule` containing `exclude_info_types.info_types` with "EMAIL_ADDRESS" the phone number findings are dropped if they overlap with EMAIL_ADDRESS finding. That leads to "555-222-2222@example.org" to generate only a single finding, namely email address. - … - `excludeByHotword` GooglePrivacyDlpV2ExcludeByHotword — The rule to exclude findings based on a hotword. For record inspection of tables, column names are considered hotwords. An example of this is to exclude a finding if it belongs to a BigQuery column that matches a specific pattern. - `proximity` GooglePrivacyDlpV2Proximity — Message for specifying a window around a finding to apply a detection rule. - … - `hotwordRegex` GooglePrivacyDlpV2Regex — Message defining a custom regular expression. - … - `matchingType` 'MATCHING_TYPE_UNSPECIFIED' | 'MATCHING_TYPE_FULL_MATCH' | 'MATCHING_TYPE_PARTIAL_MATCH' | 'MATCHING_TYPE_INVERSE_MATCH' | 'MATCHING_TYPE_RULE_SPECIFIC' — How the rule is applied, see MatchingType documentation for details. - `excludeByImageFindings` GooglePrivacyDlpV2ExcludeByImageFindings — The rule to exclude image findings based on spatial relationships with other image findings. For example, exclude an image finding if it overlaps with another image finding. This rule is silently ignored if the content being inspected is not an image. - `infoTypes` GooglePrivacyDlpV2InfoType[] — A list of image-supported infoTypes—excluding [document infoTypes](https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference#documents)—to be used as context for the exclusion rule. A finding is excluded if its bounding box has the specified spatial relationship (defined by `image_containment_type`) with a finding of an infoType in this list. For example, if `InspectionRuleSet.info_types` includes `OBJECT_TYPE/PERSON` and this `exclusion_rule` specifies `info_types` as `OBJECT_TYPE/PERSON/PASSPORT` with `image_containment_type` set to `encloses`, then `OBJECT_TYPE/PERSON` findings will be excluded if they are fully contained within the bounding box of an `OBJECT_TYPE/PERSON/PASSPORT` finding. - … - `imageContainmentType` GooglePrivacyDlpV2ImageContainmentType — Specifies the relationship between bounding boxes for image findings. - … - `hotwordRule` GooglePrivacyDlpV2HotwordRule — The rule that adjusts the likelihood of findings within a certain proximity of hotwords. - `hotwordRegex` GooglePrivacyDlpV2Regex — Message defining a custom regular expression. - `pattern` string — Pattern defining the regular expression. Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub. - `groupIndexes` integer[] — The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included. - `likelihoodAdjustment` GooglePrivacyDlpV2LikelihoodAdjustment — Message for specifying an adjustment to the likelihood of a finding as part of a detection rule. - `fixedLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Set the likelihood of a finding to a fixed value. - `relativeLikelihood` integer — Increase or decrease the likelihood by the specified number of levels. For example, if a finding would be `POSSIBLE` without the detection rule and `relative_likelihood` is 1, then it is upgraded to `LIKELY`, while a value of -1 would downgrade it to `UNLIKELY`. Likelihood may never drop below `VERY_UNLIKELY` or exceed `VERY_LIKELY`, so applying an adjustment of 1 followed by an adjustment of -1 when base likelihood is `VERY_LIKELY` will result in a final likelihood of `LIKELY`. - `proximity` GooglePrivacyDlpV2Proximity — Message for specifying a window around a finding to apply a detection rule. - `windowBefore` integer — Number of characters before the finding to consider. For tabular data, if you want to modify the likelihood of an entire column of findngs, set this to 1. For more information, see [Hotword example: Set the match likelihood of a table column] (https://cloud.google.com/sensitive-data-protection/docs/creating-custom-infotypes-likelihood#match-column-values). - `windowAfter` integer — Number of characters after the finding to consider. - `adjustmentRule` GooglePrivacyDlpV2AdjustmentRule — Rule that specifies conditions when a certain infoType's finding details should be adjusted. - `adjustByMatchingInfoTypes` GooglePrivacyDlpV2AdjustByMatchingInfoTypes — AdjustmentRule condition for matching infoTypes. - `minLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Required. Minimum likelihood of the `adjust_by_matching_info_types.info_types` finding. If the likelihood is lower than this value, Sensitive Data Protection doesn't adjust the likelihood of the `InspectionRuleSet.info_types` finding. - `matchingType` 'MATCHING_TYPE_UNSPECIFIED' | 'MATCHING_TYPE_FULL_MATCH' | 'MATCHING_TYPE_PARTIAL_MATCH' | 'MATCHING_TYPE_INVERSE_MATCH' | 'MATCHING_TYPE_RULE_SPECIFIC' — How the adjustment rule is applied. Only `MATCHING_TYPE_PARTIAL_MATCH` is supported: - Partial match: adjusts the findings of infoTypes specified in the inspection rule when they have a nonempty intersection with a finding of an infoType specified in this adjustment rule. - `infoTypes` GooglePrivacyDlpV2InfoType[] — Sensitive Data Protection adjusts the likelihood of a finding if that finding also matches one of these infoTypes. For example, you can create a rule to adjust the likelihood of a `PHONE_NUMBER` finding if the string is found within a document that is classified as `DOCUMENT_TYPE/HR/RESUME`. To configure this, set `PHONE_NUMBER` in `InspectionRuleSet.info_types`. Add an `adjustment_rule` with an `adjust_by_matching_info_types.info_types` that contains `DOCUMENT_TYPE/HR/RESUME`. In this case, the likelihood of the `PHONE_NUMBER` finding is adjusted, but the likelihood of the `DOCUMENT_TYPE/HR/RESUME` finding is not. - … - `adjustByImageFindings` GooglePrivacyDlpV2AdjustByImageFindings — AdjustmentRule condition for image findings. This rule is silently ignored if the content being inspected is not an image. - `infoTypes` GooglePrivacyDlpV2InfoType[] — A list of image-supported infoTypes—excluding [document infoTypes](https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference#documents)—to be used as context for the adjustment rule. Sensitive Data Protection adjusts the likelihood of an image finding if its bounding box has the specified spatial relationship (defined by `image_containment_type`) with a finding of an infoType in this list. For example, you can create a rule to adjust the likelihood of a `US_PASSPORT` finding if it is enclosed by a finding of `OBJECT_TYPE/PERSON/PASSPORT`. To configure this, set `US_PASSPORT` in `InspectionRuleSet.info_types`. Add an `adjustment_rule` with an `adjust_by_image_findings.info_types` that contains `OBJECT_TYPE/PERSON/PASSPORT` and `image_containment_type` set to `encloses`. In this case, the likelihood of the `US_PASSPORT` finding is adjusted, but the likelihood of the `OBJECT_TYPE/PERSON/PASSPORT` finding is not. - … - `imageContainmentType` GooglePrivacyDlpV2ImageContainmentType — Specifies the relationship between bounding boxes for image findings. - … - `minLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Required. Minimum likelihood of the `adjust_by_image_findings.info_types` finding. If the likelihood is lower than this value, Sensitive Data Protection doesn't adjust the likelihood of the `InspectionRuleSet.info_types` finding. - `likelihoodAdjustment` GooglePrivacyDlpV2LikelihoodAdjustment — Message for specifying an adjustment to the likelihood of a finding as part of a detection rule. - `fixedLikelihood` 'LIKELIHOOD_UNSPECIFIED' | 'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY' — Set the likelihood of a finding to a fixed value. - `relativeLikelihood` integer — Increase or decrease the likelihood by the specified number of levels. For example, if a finding would be `POSSIBLE` without the detection rule and `relative_likelihood` is 1, then it is upgraded to `LIKELY`, while a value of -1 would downgrade it to `UNLIKELY`. Likelihood may never drop below `VERY_UNLIKELY` or exceed `VERY_LIKELY`, so applying an adjustment of 1 followed by an adjustment of -1 when base likelihood is `VERY_LIKELY` will result in a final likelihood of `LIKELY`. - `contentOptions` string[] — Deprecated and unused. - `includeQuote` boolean — When true, a contextual quote from the data that triggered a finding is included in the response; see Finding.quote. This is not used for data profiling. - `excludeInfoTypes` boolean — When true, excludes type information of the findings. This is not used for data profiling. - `infoTypes` GooglePrivacyDlpV2InfoType[] — Restricts what info_types to look for. The values must correspond to InfoType values returned by ListInfoTypes or listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference. When no InfoTypes or CustomInfoTypes are specified in a request, the system may automatically choose a default list of detectors to run, which may change over time. If you need precise control and predictability as to what detectors are run you should specify specific InfoTypes listed in the reference, otherwise a default list will be used, which may change over time. - `name` string — Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/sensitive-data-protection/docs/infotypes-reference when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$_-]{1,64}`. - `sensitivityScore` GooglePrivacyDlpV2SensitivityScore — Score is calculated from of all elements in the data profile. A higher level means the data is more sensitive. - `score` 'SENSITIVITY_SCORE_UNSPECIFIED' | 'SENSITIVITY_LOW' | 'SENSITIVITY_UNKNOWN' | 'SENSITIVITY_MODERATE' | 'SENSITIVITY_HIGH' — The sensitivity score applied to the resource. - `version` string — Optional version name for this InfoType. ## Response `200` Successful response --- [API](https://skmtc.net/google/apis/dlp.md) · [All operations](https://skmtc.net/google/apis/dlp/llms.txt) · [OpenAPI document](https://skmtc-service-staging.skmtc.workers.dev/v1/apis/google/dlp/versions/98ced13f7159/schema)