Blame - docs/dyn/dlp_v2.projects.locations.deidentifyTemplates.html - platform/external/python/google-api-python-client

2020-10-06 16:46:05 -0700

[diff] [blame]

78

<code><a href="#close">close()</a></code></p>

79

<p class="firstline">Close httplib2 connections.</p>

80

Bu Sun Kim

d059ad8

2020-07-22 17:02:09 -0700

[diff] [blame]

81

<code><a href="#create">create(parent, body=None, x__xgafv=None)</a></code></p>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

82

<p class="firstline">Creates a DeidentifyTemplate for re-using frequently used configuration for de-identifying content, images, and storage. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.</p>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

83

84

<code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

85

<p class="firstline">Deletes a DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.</p>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

86

87

<code><a href="#get">get(name, x__xgafv=None)</a></code></p>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

88

<p class="firstline">Gets a DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.</p>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

89

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

90

<code><a href="#list">list(parent, pageSize=None, locationId=None, pageToken=None, orderBy=None, x__xgafv=None)</a></code></p>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

91

<p class="firstline">Lists DeidentifyTemplates. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.</p>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

92

93

<code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>

94

<p class="firstline">Retrieves the next page of results.</p>

95

96

<code><a href="#patch">patch(name, body=None, x__xgafv=None)</a></code></p>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

97

<p class="firstline">Updates the DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.</p>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

98

<h3>Method Details</h3>

99

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

100

<code class="details" id="close">close()</code>

101

<pre>Close httplib2 connections.</pre>

</div>

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

105

<code class="details" id="create">create(parent, body=None, x__xgafv=None)</code>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

106

<pre>Creates a DeidentifyTemplate for re-using frequently used configuration for de-identifying content, images, and storage. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

107

108

Args:

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

109

parent: string, Required. Parent resource name. The format of this value varies depending on the scope of the request (project or organization) and whether you have [specified a processing location](https://cloud.google.com/dlp/docs/specifying-location): + Projects scope, location specified: `projects/`PROJECT_ID`/locations/`LOCATION_ID + Projects scope, no location specified (defaults to global): `projects/`PROJECT_ID + Organizations scope, location specified: `organizations/`ORG_ID`/locations/`LOCATION_ID + Organizations scope, no location specified (defaults to global): `organizations/`ORG_ID The following example `parent` string specifies a parent project with the identifier `example-project`, and specifies the `europe-west3` location for processing data: parent=projects/example-project/locations/europe-west3 (required)

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

110

body: object, The request body.

111

The object takes the form of:

112

113

{ # Request message for CreateDeidentifyTemplate.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

114

"templateId": "A String", # The template id can contain uppercase and lowercase letters, numbers, and hyphens; that is, it must match the regular expression: `[a-zA-Z\d-_]+`. The maximum length is 100 characters. Can be empty to allow the system to generate one.

115

"locationId": "A String", # Deprecated. This field has no effect.

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

116

"deidentifyTemplate": { # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more. # Required. The DeidentifyTemplate to create.

117

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

118

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

119

"leaveUntransformed": { # 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. # Ignore errors

120

},

121

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

122

},

123

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

124

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

125

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

126

{ # A transformation to apply to text that is identified as a specific info_type.

127

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

128

"redactConfig": { # 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 '. # Redact

129

},

130

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

131

"newValue": { # 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. # Value to replace it with.

132

"timestampValue": "A String", # timestamp

133

"dayOfWeekValue": "A String", # day of week

134

"stringValue": "A String", # string

135

"booleanValue": True or False, # boolean

136

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

137

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

138

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

139

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

140

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

141

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

142

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

143

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

144

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

145

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

146

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

147

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

148

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

149

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

150

},

151

"characterMaskConfig": { # 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. # Mask

152

"maskingCharacter": "A 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.

153

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

154

"reverseOrder": True or False, # 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***`.

155

"charactersToIgnore": [ # 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`.

156

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

157

"charactersToSkip": "A String", # Characters to not transform when masking.

158

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

163

},

164

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

165

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

166

{ # Bucket is represented as a range, along with replacement values.

167

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

168

"timestampValue": "A String", # timestamp

169

"dayOfWeekValue": "A String", # day of week

170

"stringValue": "A String", # string

171

"booleanValue": True or False, # boolean

172

"floatValue": 3.14, # float

173

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

174

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

175

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

176

"day": 42, # 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.

177

},

178

"integerValue": "A String", # integer

179

"timeValue": { # 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`. # time of day

180

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

181

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

182

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

183

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

184

},

185

},

186

"replacementValue": { # 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. # Required. Replacement value for this bucket.

187

"timestampValue": "A String", # timestamp

188

"dayOfWeekValue": "A String", # day of week

189

"stringValue": "A String", # string

190

"booleanValue": True or False, # boolean

191

"floatValue": 3.14, # float

192

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

193

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

194

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

195

"day": 42, # 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.

196

},

197

"integerValue": "A String", # integer

198

"timeValue": { # 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`. # time of day

199

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

200

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

201

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

202

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

203

},

204

},

205

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

206

"timestampValue": "A String", # timestamp

207

"dayOfWeekValue": "A String", # day of week

208

"stringValue": "A String", # string

209

"booleanValue": True or False, # boolean

210

"floatValue": 3.14, # float

211

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

212

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

213

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

214

"day": 42, # 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.

215

},

216

"integerValue": "A String", # integer

217

"timeValue": { # 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`. # time of day

218

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

219

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

220

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

221

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

228

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

229

"timestampValue": "A String", # timestamp

230

"dayOfWeekValue": "A String", # day of week

231

"stringValue": "A String", # string

232

"booleanValue": True or False, # boolean

233

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

234

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

235

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

236

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

237

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

238

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

239

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

240

"timeValue": { # 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`. # time of day

241

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

242

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

243

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

244

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

245

},

246

},

247

"lowerBound": { # 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. # Required. 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".

248

"timestampValue": "A String", # timestamp

249

"dayOfWeekValue": "A String", # day of week

250

"stringValue": "A String", # string

251

"booleanValue": True or False, # boolean

252

"floatValue": 3.14, # float

253

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

254

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

255

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

256

"day": 42, # 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.

257

},

258

"integerValue": "A String", # integer

259

"timeValue": { # 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`. # time of day

260

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

261

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

262

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

263

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

264

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

265

},

266

"bucketSize": 3.14, # 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.

267

},

268

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

269

"partToExtract": "A String", # The part of the time to keep.

270

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

271

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

272

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

273

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

274

"wrappedKey": "A String", # Required. The wrapped data crypto key.

275

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

276

},

277

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

278

"key": "A String", # Required. A 128/192/256 bit key.

279

},

280

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

281

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

282

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

283

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

284

},

285

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

286

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

287

"name": "A String", # Name describing the field.

288

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

289

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

290

"name": "A 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/dlp/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}`.

291

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

292

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

293

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

294

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

295

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

296

},

297

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

298

"key": "A String", # Required. A 128/192/256 bit key.

299

},

300

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

301

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

302

},

303

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

304

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

305

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

306

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

307

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

308

"wrappedKey": "A String", # Required. The wrapped data crypto key.

309

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

310

},

311

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

312

"key": "A String", # Required. A 128/192/256 bit key.

313

},

314

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

315

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

316

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

317

},

318

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

319

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

320

"name": "A 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/dlp/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}`.

321

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

322

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

323

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

324

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

325

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

326

},

327

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

328

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

329

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

330

"name": "A String", # Name describing the field.

331

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

332

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

333

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

334

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

335

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

336

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

337

},

338

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

339

"key": "A String", # Required. A 128/192/256 bit key.

340

},

341

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

342

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

343

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

344

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

345

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

346

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

347

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

348

"infoTypes": [ # 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`.

349

{ # Type of information detected by the API.

350

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

356

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

357

"fieldTransformations": [ # Transform the record by applying various field transformations.

358

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

359

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

360

"redactConfig": { # 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 '. # Redact

361

},

362

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

363

"newValue": { # 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. # Value to replace it with.

364

"timestampValue": "A String", # timestamp

365

"dayOfWeekValue": "A String", # day of week

366

"stringValue": "A String", # string

367

"booleanValue": True or False, # boolean

368

"floatValue": 3.14, # float

369

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

370

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

371

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

372

"day": 42, # 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.

373

},

374

"integerValue": "A String", # integer

375

"timeValue": { # 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`. # time of day

376

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

377

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

378

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

379

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

384

"maskingCharacter": "A 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.

385

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

386

"reverseOrder": True or False, # 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***`.

387

"charactersToIgnore": [ # 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`.

388

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

389

"charactersToSkip": "A String", # Characters to not transform when masking.

390

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

395

},

396

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

397

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

398

{ # Bucket is represented as a range, along with replacement values.

399

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

400

"timestampValue": "A String", # timestamp

401

"dayOfWeekValue": "A String", # day of week

402

"stringValue": "A String", # string

403

"booleanValue": True or False, # boolean

404

"floatValue": 3.14, # float

405

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

406

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

407

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

408

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

409

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

410

"integerValue": "A String", # integer

411

"timeValue": { # 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`. # time of day

412

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

413

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

414

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

415

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

416

},

417

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

418

"replacementValue": { # 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. # Required. Replacement value for this bucket.

419

"timestampValue": "A String", # timestamp

420

"dayOfWeekValue": "A String", # day of week

421

"stringValue": "A String", # string

422

"booleanValue": True or False, # boolean

423

"floatValue": 3.14, # float

424

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

425

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

426

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

427

"day": 42, # 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.

428

},

429

"integerValue": "A String", # integer

430

"timeValue": { # 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`. # time of day

431

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

432

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

433

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

434

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

435

},

436

},

437

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

438

"timestampValue": "A String", # timestamp

439

"dayOfWeekValue": "A String", # day of week

440

"stringValue": "A String", # string

441

"booleanValue": True or False, # boolean

442

"floatValue": 3.14, # float

443

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

444

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

445

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

446

"day": 42, # 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.

447

},

448

"integerValue": "A String", # integer

449

"timeValue": { # 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`. # time of day

450

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

451

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

452

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

453

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

458

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

459

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

460

"upperBound": { # 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. # Required. 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+".

461

"timestampValue": "A String", # timestamp

462

"dayOfWeekValue": "A String", # day of week

463

"stringValue": "A String", # string

464

"booleanValue": True or False, # boolean

465

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

466

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

467

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

468

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

469

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

470

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

471

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

472

"timeValue": { # 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`. # time of day

473

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

474

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

475

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

476

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

477

},

478

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

479

"lowerBound": { # 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. # Required. 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".

480

"timestampValue": "A String", # timestamp

481

"dayOfWeekValue": "A String", # day of week

482

"stringValue": "A String", # string

483

"booleanValue": True or False, # boolean

484

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

485

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

486

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

487

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

488

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

489

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

490

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

491

"timeValue": { # 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`. # time of day

492

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

493

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

494

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

495

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

496

},

497

},

498

"bucketSize": 3.14, # 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.

499

},

500

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

501

"partToExtract": "A String", # The part of the time to keep.

502

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

503

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

504

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

505

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

506

"wrappedKey": "A String", # Required. The wrapped data crypto key.

507

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

508

},

509

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

510

"key": "A String", # Required. A 128/192/256 bit key.

511

},

512

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

513

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

514

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

515

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

516

},

517

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

518

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

519

"name": "A String", # Name describing the field.

520

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

521

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

522

"name": "A 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/dlp/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}`.

523

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

524

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

525

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

526

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

527

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

528

},

529

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

530

"key": "A String", # Required. A 128/192/256 bit key.

531

},

532

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

533

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

538

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

539

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

540

"wrappedKey": "A String", # Required. The wrapped data crypto key.

541

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

542

},

543

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

544

"key": "A String", # Required. A 128/192/256 bit key.

545

},

546

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

547

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

548

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

549

},

550

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

551

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

552

"name": "A 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/dlp/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}`.

553

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

554

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

555

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

556

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

557

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

558

},

559

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

560

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

561

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

562

"name": "A String", # Name describing the field.

563

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

564

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

565

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

566

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

567

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

568

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

569

},

570

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

571

"key": "A String", # Required. A 128/192/256 bit key.

572

},

573

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

574

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

575

},

576

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

577

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

578

},

579

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

580

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

581

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

582

{ # A transformation to apply to text that is identified as a specific info_type.

583

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

584

"redactConfig": { # 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 '. # Redact

585

},

586

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

587

"newValue": { # 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. # Value to replace it with.

588

"timestampValue": "A String", # timestamp

589

"dayOfWeekValue": "A String", # day of week

590

"stringValue": "A String", # string

591

"booleanValue": True or False, # boolean

592

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

593

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

594

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

595

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

596

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

597

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

598

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

599

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

600

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

601

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

602

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

603

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

604

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

605

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

606

},

607

"characterMaskConfig": { # 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. # Mask

608

"maskingCharacter": "A 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.

609

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

610

"reverseOrder": True or False, # 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***`.

611

"charactersToIgnore": [ # 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`.

612

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

613

"charactersToSkip": "A String", # Characters to not transform when masking.

614

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

619

},

620

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

621

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

622

{ # Bucket is represented as a range, along with replacement values.

623

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

624

"timestampValue": "A String", # timestamp

625

"dayOfWeekValue": "A String", # day of week

626

"stringValue": "A String", # string

627

"booleanValue": True or False, # boolean

628

"floatValue": 3.14, # float

629

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

630

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

631

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

632

"day": 42, # 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.

633

},

634

"integerValue": "A String", # integer

635

"timeValue": { # 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`. # time of day

636

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

637

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

638

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

639

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

640

},

641

},

642

"replacementValue": { # 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. # Required. Replacement value for this bucket.

643

"timestampValue": "A String", # timestamp

644

"dayOfWeekValue": "A String", # day of week

645

"stringValue": "A String", # string

646

"booleanValue": True or False, # boolean

647

"floatValue": 3.14, # float

648

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

649

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

650

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

651

"day": 42, # 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.

652

},

653

"integerValue": "A String", # integer

654

"timeValue": { # 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`. # time of day

655

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

656

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

657

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

658

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

659

},

660

},

661

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

662

"timestampValue": "A String", # timestamp

663

"dayOfWeekValue": "A String", # day of week

664

"stringValue": "A String", # string

665

"booleanValue": True or False, # boolean

666

"floatValue": 3.14, # float

667

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

668

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

669

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

670

"day": 42, # 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.

671

},

672

"integerValue": "A String", # integer

673

"timeValue": { # 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`. # time of day

674

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

675

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

676

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

677

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

684

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

685

"timestampValue": "A String", # timestamp

686

"dayOfWeekValue": "A String", # day of week

687

"stringValue": "A String", # string

688

"booleanValue": True or False, # boolean

689

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

690

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

691

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

692

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

693

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

694

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

695

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

696

"timeValue": { # 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`. # time of day

697

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

698

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

699

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

700

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

701

},

702

},

703

"lowerBound": { # 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. # Required. 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".

704

"timestampValue": "A String", # timestamp

705

"dayOfWeekValue": "A String", # day of week

706

"stringValue": "A String", # string

707

"booleanValue": True or False, # boolean

708

"floatValue": 3.14, # float

709

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

710

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

711

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

712

"day": 42, # 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.

713

},

714

"integerValue": "A String", # integer

715

"timeValue": { # 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`. # time of day

716

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

717

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

718

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

719

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

720

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

721

},

722

"bucketSize": 3.14, # 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.

723

},

724

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

725

"partToExtract": "A String", # The part of the time to keep.

726

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

727

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

728

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

729

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

730

"wrappedKey": "A String", # Required. The wrapped data crypto key.

731

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

732

},

733

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

734

"key": "A String", # Required. A 128/192/256 bit key.

735

},

736

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

737

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

738

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

739

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

740

},

741

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

742

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

743

"name": "A String", # Name describing the field.

744

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

745

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

746

"name": "A 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/dlp/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}`.

747

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

748

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

749

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

750

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

751

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

752

},

753

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

754

"key": "A String", # Required. A 128/192/256 bit key.

755

},

756

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

757

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

758

},

759

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

760

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

761

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

762

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

763

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

764

"wrappedKey": "A String", # Required. The wrapped data crypto key.

765

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

766

},

767

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

768

"key": "A String", # Required. A 128/192/256 bit key.

769

},

770

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

771

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

772

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

773

},

774

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

775

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

776

"name": "A 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/dlp/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}`.

777

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

778

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

779

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

780

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

781

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

782

},

783

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

784

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

785

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

786

"name": "A String", # Name describing the field.

787

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

788

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

789

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

790

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

791

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

792

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

793

},

794

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

795

"key": "A String", # Required. A 128/192/256 bit key.

796

},

797

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

798

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

799

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

800

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

801

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

802

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

803

},

804

"infoTypes": [ # 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`.

805

{ # Type of information detected by the API.

806

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

812

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

813

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

814

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

815

"conditions": [ # A collection of conditions.

816

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

817

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

818

"timestampValue": "A String", # timestamp

819

"dayOfWeekValue": "A String", # day of week

820

"stringValue": "A String", # string

821

"booleanValue": True or False, # boolean

822

"floatValue": 3.14, # float

823

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

824

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

825

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

826

"day": 42, # 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.

827

},

828

"integerValue": "A String", # integer

829

"timeValue": { # 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`. # time of day

830

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

831

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

832

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

833

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

834

},

835

},

836

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

837

"name": "A String", # Name describing the field.

838

},

839

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

844

},

845

},

846

"fields": [ # Required. Input field(s) to apply the transformation to.

847

{ # General identifier of a data field in a storage service.

848

"name": "A String", # Name describing the field.

849

},

850

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

851

},

852

],

853

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

854

{ # Configuration to suppress records whose suppression conditions evaluate to true.

855

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

856

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

857

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

858

"conditions": [ # A collection of conditions.

859

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

860

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

861

"timestampValue": "A String", # timestamp

862

"dayOfWeekValue": "A String", # day of week

863

"stringValue": "A String", # string

864

"booleanValue": True or False, # boolean

865

"floatValue": 3.14, # float

866

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

867

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

868

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

869

"day": 42, # 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.

870

},

871

"integerValue": "A String", # integer

872

"timeValue": { # 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`. # time of day

873

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

874

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

875

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

876

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

877

},

878

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

879

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

880

"name": "A String", # Name describing the field.

881

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

882

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

883

},

884

],

885

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

886

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

892

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

893

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

894

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

895

"description": "A String", # Short description (max 256 chars).

896

"displayName": "A String", # Display name (max 256 chars).

897

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

898

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

899

}

900

901

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

An object of the form:

908

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

909

{ # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more.

910

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

911

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

912

"leaveUntransformed": { # 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. # Ignore errors

913

},

914

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

915

},

916

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

917

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

918

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

919

{ # A transformation to apply to text that is identified as a specific info_type.

920

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

921

"redactConfig": { # 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 '. # Redact

922

},

923

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

924

"newValue": { # 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. # Value to replace it with.

925

"timestampValue": "A String", # timestamp

926

"dayOfWeekValue": "A String", # day of week

927

"stringValue": "A String", # string

928

"booleanValue": True or False, # boolean

929

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

930

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

931

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

932

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

933

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

934

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

935

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

936

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

937

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

938

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

939

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

940

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

941

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

942

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

943

},

944

"characterMaskConfig": { # 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. # Mask

945

"maskingCharacter": "A 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.

946

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

947

"reverseOrder": True or False, # 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***`.

948

"charactersToIgnore": [ # 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`.

949

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

950

"charactersToSkip": "A String", # Characters to not transform when masking.

951

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

956

},

957

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

958

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

959

{ # Bucket is represented as a range, along with replacement values.

960

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

961

"timestampValue": "A String", # timestamp

962

"dayOfWeekValue": "A String", # day of week

963

"stringValue": "A String", # string

964

"booleanValue": True or False, # boolean

965

"floatValue": 3.14, # float

966

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

967

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

968

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

969

"day": 42, # 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.

970

},

971

"integerValue": "A String", # integer

972

"timeValue": { # 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`. # time of day

973

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

974

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

975

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

976

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

977

},

978

},

979

"replacementValue": { # 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. # Required. Replacement value for this bucket.

980

"timestampValue": "A String", # timestamp

981

"dayOfWeekValue": "A String", # day of week

982

"stringValue": "A String", # string

983

"booleanValue": True or False, # boolean

984

"floatValue": 3.14, # float

985

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

986

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

987

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

988

"day": 42, # 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.

989

},

990

"integerValue": "A String", # integer

991

"timeValue": { # 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`. # time of day

992

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

993

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

994

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

995

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

996

},

997

},

998

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

999

"timestampValue": "A String", # timestamp

1000

"dayOfWeekValue": "A String", # day of week

1001

"stringValue": "A String", # string

1002

"booleanValue": True or False, # boolean

1003

"floatValue": 3.14, # float

1004

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1005

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1006

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1007

"day": 42, # 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.

1008

},

1009

"integerValue": "A String", # integer

1010

"timeValue": { # 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`. # time of day

1011

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1012

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1013

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1014

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1021

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1022

"timestampValue": "A String", # timestamp

1023

"dayOfWeekValue": "A String", # day of week

1024

"stringValue": "A String", # string

1025

"booleanValue": True or False, # boolean

1026

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1027

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1028

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1029

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1030

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1031

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1032

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1033

"timeValue": { # 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`. # time of day

1034

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1035

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1036

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1037

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1038

},

1039

},

1040

"lowerBound": { # 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. # Required. 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".

1041

"timestampValue": "A String", # timestamp

1042

"dayOfWeekValue": "A String", # day of week

1043

"stringValue": "A String", # string

1044

"booleanValue": True or False, # boolean

1045

"floatValue": 3.14, # float

1046

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1047

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1048

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1049

"day": 42, # 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.

1050

},

1051

"integerValue": "A String", # integer

1052

"timeValue": { # 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`. # time of day

1053

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1054

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1055

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1056

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1057

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1058

},

1059

"bucketSize": 3.14, # 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.

1060

},

1061

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

1062

"partToExtract": "A String", # The part of the time to keep.

1063

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1064

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

1065

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

1066

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1067

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1068

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1069

},

1070

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1071

"key": "A String", # Required. A 128/192/256 bit key.

1072

},

1073

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1074

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1075

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1076

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1077

},

1078

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1079

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

1080

"name": "A String", # Name describing the field.

1081

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1082

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

1083

"name": "A 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/dlp/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}`.

1084

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1085

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

1086

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1087

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1088

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1089

},

1090

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1091

"key": "A String", # Required. A 128/192/256 bit key.

1092

},

1093

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1094

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1095

},

1096

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1097

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1098

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1099

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

1100

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1101

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1102

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1103

},

1104

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1105

"key": "A String", # Required. A 128/192/256 bit key.

1106

},

1107

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1108

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1109

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1110

},

1111

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1112

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

1113

"name": "A 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/dlp/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}`.

1114

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1115

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

1116

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

1117

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

1118

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1119

},

1120

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1121

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1122

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

1123

"name": "A String", # Name describing the field.

1124

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1125

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1126

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

1127

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1128

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1129

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1130

},

1131

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1132

"key": "A String", # Required. A 128/192/256 bit key.

1133

},

1134

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1135

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1136

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1137

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1138

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1139

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

1140

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1141

"infoTypes": [ # 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`.

1142

{ # Type of information detected by the API.

1143

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1149

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

1150

"fieldTransformations": [ # Transform the record by applying various field transformations.

1151

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1152

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

1153

"redactConfig": { # 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 '. # Redact

1154

},

1155

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

1156

"newValue": { # 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. # Value to replace it with.

1157

"timestampValue": "A String", # timestamp

1158

"dayOfWeekValue": "A String", # day of week

1159

"stringValue": "A String", # string

1160

"booleanValue": True or False, # boolean

1161

"floatValue": 3.14, # float

1162

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1163

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1164

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1165

"day": 42, # 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.

1166

},

1167

"integerValue": "A String", # integer

1168

"timeValue": { # 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`. # time of day

1169

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1170

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1171

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1172

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

1177

"maskingCharacter": "A 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.

1178

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

1179

"reverseOrder": True or False, # 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***`.

1180

"charactersToIgnore": [ # 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`.

1181

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

1182

"charactersToSkip": "A String", # Characters to not transform when masking.

1183

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

1188

},

1189

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

1190

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

1191

{ # Bucket is represented as a range, along with replacement values.

1192

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

1193

"timestampValue": "A String", # timestamp

1194

"dayOfWeekValue": "A String", # day of week

1195

"stringValue": "A String", # string

1196

"booleanValue": True or False, # boolean

1197

"floatValue": 3.14, # float

1198

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1199

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1200

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1201

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1202

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1203

"integerValue": "A String", # integer

1204

"timeValue": { # 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`. # time of day

1205

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1206

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1207

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1208

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1209

},

1210

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1211

"replacementValue": { # 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. # Required. Replacement value for this bucket.

1212

"timestampValue": "A String", # timestamp

1213

"dayOfWeekValue": "A String", # day of week

1214

"stringValue": "A String", # string

1215

"booleanValue": True or False, # boolean

1216

"floatValue": 3.14, # float

1217

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1218

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1219

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1220

"day": 42, # 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.

1221

},

1222

"integerValue": "A String", # integer

1223

"timeValue": { # 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`. # time of day

1224

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1225

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1226

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1227

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1228

},

1229

},

1230

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

1231

"timestampValue": "A String", # timestamp

1232

"dayOfWeekValue": "A String", # day of week

1233

"stringValue": "A String", # string

1234

"booleanValue": True or False, # boolean

1235

"floatValue": 3.14, # float

1236

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1237

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1238

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1239

"day": 42, # 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.

1240

},

1241

"integerValue": "A String", # integer

1242

"timeValue": { # 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`. # time of day

1243

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1244

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1245

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1246

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1251

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1252

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1253

"upperBound": { # 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. # Required. 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+".

1254

"timestampValue": "A String", # timestamp

1255

"dayOfWeekValue": "A String", # day of week

1256

"stringValue": "A String", # string

1257

"booleanValue": True or False, # boolean

1258

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1259

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1260

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1261

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1262

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1263

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1264

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1265

"timeValue": { # 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`. # time of day

1266

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1267

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1268

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1269

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1270

},

1271

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1272

"lowerBound": { # 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. # Required. 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".

1273

"timestampValue": "A String", # timestamp

1274

"dayOfWeekValue": "A String", # day of week

1275

"stringValue": "A String", # string

1276

"booleanValue": True or False, # boolean

1277

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1278

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1279

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1280

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1281

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1282

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1283

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1284

"timeValue": { # 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`. # time of day

1285

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1286

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1287

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1288

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1289

},

1290

},

1291

"bucketSize": 3.14, # 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.

1292

},

1293

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

1294

"partToExtract": "A String", # The part of the time to keep.

1295

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1296

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

1297

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

1298

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1299

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1300

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1301

},

1302

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1303

"key": "A String", # Required. A 128/192/256 bit key.

1304

},

1305

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1306

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1307

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1308

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1309

},

1310

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1311

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

1312

"name": "A String", # Name describing the field.

1313

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1314

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

1315

"name": "A 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/dlp/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}`.

1316

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1317

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

1318

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1319

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1320

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1321

},

1322

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1323

"key": "A String", # Required. A 128/192/256 bit key.

1324

},

1325

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1326

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1331

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

1332

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1333

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1334

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1335

},

1336

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1337

"key": "A String", # Required. A 128/192/256 bit key.

1338

},

1339

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1340

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1341

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1342

},

1343

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1344

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

1345

"name": "A 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/dlp/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}`.

1346

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1347

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

1348

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

1349

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

1350

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1351

},

1352

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1353

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1354

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

1355

"name": "A String", # Name describing the field.

1356

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1357

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1358

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

1359

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1360

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1361

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1362

},

1363

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1364

"key": "A String", # Required. A 128/192/256 bit key.

1365

},

1366

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1367

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1368

},

1369

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1370

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1371

},

1372

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1373

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

1374

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

1375

{ # A transformation to apply to text that is identified as a specific info_type.

1376

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1377

"redactConfig": { # 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 '. # Redact

1378

},

1379

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

1380

"newValue": { # 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. # Value to replace it with.

1381

"timestampValue": "A String", # timestamp

1382

"dayOfWeekValue": "A String", # day of week

1383

"stringValue": "A String", # string

1384

"booleanValue": True or False, # boolean

1385

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1386

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1387

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1388

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1389

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1390

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1391

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1392

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1393

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1394

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1395

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1396

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1397

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1398

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1399

},

1400

"characterMaskConfig": { # 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. # Mask

1401

"maskingCharacter": "A 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.

1402

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

1403

"reverseOrder": True or False, # 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***`.

1404

"charactersToIgnore": [ # 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`.

1405

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

1406

"charactersToSkip": "A String", # Characters to not transform when masking.

1407

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

1412

},

1413

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

1414

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

1415

{ # Bucket is represented as a range, along with replacement values.

1416

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

1417

"timestampValue": "A String", # timestamp

1418

"dayOfWeekValue": "A String", # day of week

1419

"stringValue": "A String", # string

1420

"booleanValue": True or False, # boolean

1421

"floatValue": 3.14, # float

1422

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1423

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1424

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1425

"day": 42, # 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.

1426

},

1427

"integerValue": "A String", # integer

1428

"timeValue": { # 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`. # time of day

1429

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1430

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1431

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1432

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1433

},

1434

},

1435

"replacementValue": { # 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. # Required. Replacement value for this bucket.

1436

"timestampValue": "A String", # timestamp

1437

"dayOfWeekValue": "A String", # day of week

1438

"stringValue": "A String", # string

1439

"booleanValue": True or False, # boolean

1440

"floatValue": 3.14, # float

1441

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1442

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1443

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1444

"day": 42, # 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.

1445

},

1446

"integerValue": "A String", # integer

1447

"timeValue": { # 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`. # time of day

1448

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1449

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1450

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1451

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1452

},

1453

},

1454

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

1455

"timestampValue": "A String", # timestamp

1456

"dayOfWeekValue": "A String", # day of week

1457

"stringValue": "A String", # string

1458

"booleanValue": True or False, # boolean

1459

"floatValue": 3.14, # float

1460

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1461

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1462

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1463

"day": 42, # 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.

1464

},

1465

"integerValue": "A String", # integer

1466

"timeValue": { # 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`. # time of day

1467

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1468

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1469

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1470

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1477

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1478

"timestampValue": "A String", # timestamp

1479

"dayOfWeekValue": "A String", # day of week

1480

"stringValue": "A String", # string

1481

"booleanValue": True or False, # boolean

1482

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1483

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1484

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1485

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1486

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1487

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1488

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1489

"timeValue": { # 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`. # time of day

1490

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1491

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1492

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1493

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1494

},

1495

},

1496

"lowerBound": { # 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. # Required. 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".

1497

"timestampValue": "A String", # timestamp

1498

"dayOfWeekValue": "A String", # day of week

1499

"stringValue": "A String", # string

1500

"booleanValue": True or False, # boolean

1501

"floatValue": 3.14, # float

1502

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1503

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1504

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1505

"day": 42, # 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.

1506

},

1507

"integerValue": "A String", # integer

1508

"timeValue": { # 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`. # time of day

1509

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1510

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1511

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1512

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1513

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1514

},

1515

"bucketSize": 3.14, # 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.

1516

},

1517

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

1518

"partToExtract": "A String", # The part of the time to keep.

1519

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1520

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

1521

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

1522

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1523

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1524

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1525

},

1526

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1527

"key": "A String", # Required. A 128/192/256 bit key.

1528

},

1529

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1530

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1531

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1532

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1533

},

1534

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1535

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

1536

"name": "A String", # Name describing the field.

1537

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1538

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

1539

"name": "A 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/dlp/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}`.

1540

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1541

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

1542

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1543

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1544

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1545

},

1546

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1547

"key": "A String", # Required. A 128/192/256 bit key.

1548

},

1549

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1550

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1551

},

1552

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1553

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1554

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1555

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

1556

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1557

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1558

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1559

},

1560

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1561

"key": "A String", # Required. A 128/192/256 bit key.

1562

},

1563

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1564

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1565

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1566

},

1567

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1568

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

1569

"name": "A 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/dlp/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}`.

1570

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1571

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

1572

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

1573

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

1574

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1575

},

1576

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1577

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1578

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

1579

"name": "A String", # Name describing the field.

1580

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1581

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1582

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

1583

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1584

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1585

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1586

},

1587

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1588

"key": "A String", # Required. A 128/192/256 bit key.

1589

},

1590

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1591

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1592

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1593

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1594

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1595

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1596

},

1597

"infoTypes": [ # 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`.

1598

{ # Type of information detected by the API.

1599

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1605

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

1606

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

1607

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

1608

"conditions": [ # A collection of conditions.

1609

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

1610

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

1611

"timestampValue": "A String", # timestamp

1612

"dayOfWeekValue": "A String", # day of week

1613

"stringValue": "A String", # string

1614

"booleanValue": True or False, # boolean

1615

"floatValue": 3.14, # float

1616

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1617

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1618

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1619

"day": 42, # 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.

1620

},

1621

"integerValue": "A String", # integer

1622

"timeValue": { # 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`. # time of day

1623

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1624

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1625

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1626

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1627

},

1628

},

1629

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

1630

"name": "A String", # Name describing the field.

1631

},

1632

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

1637

},

1638

},

1639

"fields": [ # Required. Input field(s) to apply the transformation to.

1640

{ # General identifier of a data field in a storage service.

1641

"name": "A String", # Name describing the field.

1642

},

1643

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1644

},

1645

],

1646

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

1647

{ # Configuration to suppress records whose suppression conditions evaluate to true.

1648

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

1649

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

1650

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

1651

"conditions": [ # A collection of conditions.

1652

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1653

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

1654

"timestampValue": "A String", # timestamp

1655

"dayOfWeekValue": "A String", # day of week

1656

"stringValue": "A String", # string

1657

"booleanValue": True or False, # boolean

1658

"floatValue": 3.14, # float

1659

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1660

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1661

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1662

"day": 42, # 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.

1663

},

1664

"integerValue": "A String", # integer

1665

"timeValue": { # 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`. # time of day

1666

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1667

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1668

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1669

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1670

},

1671

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1672

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

1673

"name": "A String", # Name describing the field.

1674

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1675

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1676

},

1677

],

1678

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1679

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1685

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1686

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

1687

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

1688

"description": "A String", # Short description (max 256 chars).

1689

"displayName": "A String", # Display name (max 256 chars).

1690

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

}</pre>

</div>

<code class="details" id="delete">delete(name, x__xgafv=None)</code>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1696

<pre>Deletes a DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1697

1698

Args:

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1699

name: string, Required. Resource name of the organization and deidentify template to be deleted, for example `organizations/433245324/deidentifyTemplates/432452342` or projects/project-id/deidentifyTemplates/432452342. (required)

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1700

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

An object of the form:

1707

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1708

{ # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

}</pre>

</div>

<code class="details" id="get">get(name, x__xgafv=None)</code>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1714

<pre>Gets a DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1715

1716

Args:

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1717

name: string, Required. Resource name of the organization and deidentify template to be read, for example `organizations/433245324/deidentifyTemplates/432452342` or projects/project-id/deidentifyTemplates/432452342. (required)

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1718

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

An object of the form:

1725

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

1726

{ # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more.

1727

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1728

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

1729

"leaveUntransformed": { # 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. # Ignore errors

1730

},

1731

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

1732

},

1733

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1734

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

1735

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

1736

{ # A transformation to apply to text that is identified as a specific info_type.

1737

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1738

"redactConfig": { # 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 '. # Redact

1739

},

1740

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

1741

"newValue": { # 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. # Value to replace it with.

1742

"timestampValue": "A String", # timestamp

1743

"dayOfWeekValue": "A String", # day of week

1744

"stringValue": "A String", # string

1745

"booleanValue": True or False, # boolean

1746

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1747

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1748

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1749

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1750

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1751

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1752

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1753

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1754

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1755

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1756

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1757

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1758

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1759

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1760

},

1761

"characterMaskConfig": { # 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. # Mask

1762

"maskingCharacter": "A 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.

1763

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

1764

"reverseOrder": True or False, # 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***`.

1765

"charactersToIgnore": [ # 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`.

1766

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

1767

"charactersToSkip": "A String", # Characters to not transform when masking.

1768

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

1773

},

1774

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

1775

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

1776

{ # Bucket is represented as a range, along with replacement values.

1777

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

1778

"timestampValue": "A String", # timestamp

1779

"dayOfWeekValue": "A String", # day of week

1780

"stringValue": "A String", # string

1781

"booleanValue": True or False, # boolean

1782

"floatValue": 3.14, # float

1783

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1784

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1785

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1786

"day": 42, # 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.

1787

},

1788

"integerValue": "A String", # integer

1789

"timeValue": { # 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`. # time of day

1790

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1791

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1792

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1793

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1794

},

1795

},

1796

"replacementValue": { # 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. # Required. Replacement value for this bucket.

1797

"timestampValue": "A String", # timestamp

1798

"dayOfWeekValue": "A String", # day of week

1799

"stringValue": "A String", # string

1800

"booleanValue": True or False, # boolean

1801

"floatValue": 3.14, # float

1802

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1803

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1804

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1805

"day": 42, # 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.

1806

},

1807

"integerValue": "A String", # integer

1808

"timeValue": { # 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`. # time of day

1809

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1810

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1811

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1812

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

1813

},

1814

},

1815

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

1816

"timestampValue": "A String", # timestamp

1817

"dayOfWeekValue": "A String", # day of week

1818

"stringValue": "A String", # string

1819

"booleanValue": True or False, # boolean

1820

"floatValue": 3.14, # float

1821

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1822

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1823

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1824

"day": 42, # 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.

1825

},

1826

"integerValue": "A String", # integer

1827

"timeValue": { # 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`. # time of day

1828

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1829

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1830

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1831

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1838

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1839

"timestampValue": "A String", # timestamp

1840

"dayOfWeekValue": "A String", # day of week

1841

"stringValue": "A String", # string

1842

"booleanValue": True or False, # boolean

1843

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1844

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1845

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1846

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1847

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1848

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1849

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1850

"timeValue": { # 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`. # time of day

1851

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1852

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1853

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1854

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1855

},

1856

},

1857

"lowerBound": { # 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. # Required. 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".

1858

"timestampValue": "A String", # timestamp

1859

"dayOfWeekValue": "A String", # day of week

1860

"stringValue": "A String", # string

1861

"booleanValue": True or False, # boolean

1862

"floatValue": 3.14, # float

1863

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1864

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1865

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1866

"day": 42, # 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.

1867

},

1868

"integerValue": "A String", # integer

1869

"timeValue": { # 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`. # time of day

1870

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1871

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1872

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1873

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1874

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1875

},

1876

"bucketSize": 3.14, # 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.

1877

},

1878

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

1879

"partToExtract": "A String", # The part of the time to keep.

1880

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1881

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

1882

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

1883

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1884

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1885

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1886

},

1887

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1888

"key": "A String", # Required. A 128/192/256 bit key.

1889

},

1890

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1891

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1892

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1893

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1894

},

1895

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

1896

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

1897

"name": "A String", # Name describing the field.

1898

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1899

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

1900

"name": "A 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/dlp/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}`.

1901

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1902

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

1903

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1904

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1905

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1906

},

1907

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1908

"key": "A String", # Required. A 128/192/256 bit key.

1909

},

1910

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1911

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1912

},

1913

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1914

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1915

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1916

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

1917

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

1918

"wrappedKey": "A String", # Required. The wrapped data crypto key.

1919

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

1920

},

1921

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1922

"key": "A String", # Required. A 128/192/256 bit key.

1923

},

1924

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1925

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1926

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1927

},

1928

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1929

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

1930

"name": "A 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/dlp/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}`.

1931

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1932

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

1933

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

1934

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

1935

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1936

},

1937

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1938

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1939

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

1940

"name": "A String", # Name describing the field.

1941

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1942

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1943

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

1944

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1945

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1946

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1947

},

1948

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

1949

"key": "A String", # Required. A 128/192/256 bit key.

1950

},

1951

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

1952

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

1953

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

1954

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1955

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

1956

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

1957

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1958

"infoTypes": [ # 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`.

1959

{ # Type of information detected by the API.

1960

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

1966

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

1967

"fieldTransformations": [ # Transform the record by applying various field transformations.

1968

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

1969

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

1970

"redactConfig": { # 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 '. # Redact

1971

},

1972

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

1973

"newValue": { # 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. # Value to replace it with.

1974

"timestampValue": "A String", # timestamp

1975

"dayOfWeekValue": "A String", # day of week

1976

"stringValue": "A String", # string

1977

"booleanValue": True or False, # boolean

1978

"floatValue": 3.14, # float

1979

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

1980

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

1981

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

1982

"day": 42, # 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.

1983

},

1984

"integerValue": "A String", # integer

1985

"timeValue": { # 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`. # time of day

1986

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

1987

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

1988

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

1989

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

1994

"maskingCharacter": "A 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.

1995

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

1996

"reverseOrder": True or False, # 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***`.

1997

"charactersToIgnore": [ # 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`.

1998

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

1999

"charactersToSkip": "A String", # Characters to not transform when masking.

2000

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

2005

},

2006

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

2007

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

2008

{ # Bucket is represented as a range, along with replacement values.

2009

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

2010

"timestampValue": "A String", # timestamp

2011

"dayOfWeekValue": "A String", # day of week

2012

"stringValue": "A String", # string

2013

"booleanValue": True or False, # boolean

2014

"floatValue": 3.14, # float

2015

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2016

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2017

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2018

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2019

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2020

"integerValue": "A String", # integer

2021

"timeValue": { # 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`. # time of day

2022

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2023

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2024

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2025

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2026

},

2027

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2028

"replacementValue": { # 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. # Required. Replacement value for this bucket.

2029

"timestampValue": "A String", # timestamp

2030

"dayOfWeekValue": "A String", # day of week

2031

"stringValue": "A String", # string

2032

"booleanValue": True or False, # boolean

2033

"floatValue": 3.14, # float

2034

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2035

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2036

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2037

"day": 42, # 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.

2038

},

2039

"integerValue": "A String", # integer

2040

"timeValue": { # 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`. # time of day

2041

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2042

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2043

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2044

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2045

},

2046

},

2047

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

2048

"timestampValue": "A String", # timestamp

2049

"dayOfWeekValue": "A String", # day of week

2050

"stringValue": "A String", # string

2051

"booleanValue": True or False, # boolean

2052

"floatValue": 3.14, # float

2053

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2054

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2055

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2056

"day": 42, # 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.

2057

},

2058

"integerValue": "A String", # integer

2059

"timeValue": { # 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`. # time of day

2060

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2061

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2062

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2063

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2068

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2069

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2070

"upperBound": { # 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. # Required. 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+".

2071

"timestampValue": "A String", # timestamp

2072

"dayOfWeekValue": "A String", # day of week

2073

"stringValue": "A String", # string

2074

"booleanValue": True or False, # boolean

2075

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2076

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2077

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2078

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2079

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2080

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2081

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2082

"timeValue": { # 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`. # time of day

2083

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2084

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2085

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2086

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2087

},

2088

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2089

"lowerBound": { # 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. # Required. 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".

2090

"timestampValue": "A String", # timestamp

2091

"dayOfWeekValue": "A String", # day of week

2092

"stringValue": "A String", # string

2093

"booleanValue": True or False, # boolean

2094

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2095

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2096

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2097

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2098

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2099

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2100

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2101

"timeValue": { # 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`. # time of day

2102

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2103

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2104

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2105

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2106

},

2107

},

2108

"bucketSize": 3.14, # 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.

2109

},

2110

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

2111

"partToExtract": "A String", # The part of the time to keep.

2112

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2113

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

2114

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

2115

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2116

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2117

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2118

},

2119

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2120

"key": "A String", # Required. A 128/192/256 bit key.

2121

},

2122

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2123

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2124

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2125

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2126

},

2127

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2128

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

2129

"name": "A String", # Name describing the field.

2130

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2131

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

2132

"name": "A 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/dlp/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}`.

2133

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2134

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

2135

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2136

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2137

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2138

},

2139

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2140

"key": "A String", # Required. A 128/192/256 bit key.

2141

},

2142

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2143

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2148

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

2149

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2150

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2151

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2152

},

2153

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2154

"key": "A String", # Required. A 128/192/256 bit key.

2155

},

2156

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2157

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2158

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2159

},

2160

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2161

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

2162

"name": "A 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/dlp/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}`.

2163

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2164

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

2165

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

2166

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

2167

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2168

},

2169

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2170

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2171

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

2172

"name": "A String", # Name describing the field.

2173

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2174

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2175

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

2176

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2177

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2178

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2179

},

2180

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2181

"key": "A String", # Required. A 128/192/256 bit key.

2182

},

2183

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2184

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2185

},

2186

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2187

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2188

},

2189

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2190

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

2191

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

2192

{ # A transformation to apply to text that is identified as a specific info_type.

2193

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2194

"redactConfig": { # 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 '. # Redact

2195

},

2196

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

2197

"newValue": { # 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. # Value to replace it with.

2198

"timestampValue": "A String", # timestamp

2199

"dayOfWeekValue": "A String", # day of week

2200

"stringValue": "A String", # string

2201

"booleanValue": True or False, # boolean

2202

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2203

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2204

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2205

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2206

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2207

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2208

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2209

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2210

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2211

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2212

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2213

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2214

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2215

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2216

},

2217

"characterMaskConfig": { # 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. # Mask

2218

"maskingCharacter": "A 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.

2219

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

2220

"reverseOrder": True or False, # 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***`.

2221

"charactersToIgnore": [ # 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`.

2222

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

2223

"charactersToSkip": "A String", # Characters to not transform when masking.

2224

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

2229

},

2230

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

2231

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

2232

{ # Bucket is represented as a range, along with replacement values.

2233

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

2234

"timestampValue": "A String", # timestamp

2235

"dayOfWeekValue": "A String", # day of week

2236

"stringValue": "A String", # string

2237

"booleanValue": True or False, # boolean

2238

"floatValue": 3.14, # float

2239

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2240

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2241

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2242

"day": 42, # 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.

2243

},

2244

"integerValue": "A String", # integer

2245

"timeValue": { # 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`. # time of day

2246

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2247

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2248

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2249

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2250

},

2251

},

2252

"replacementValue": { # 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. # Required. Replacement value for this bucket.

2253

"timestampValue": "A String", # timestamp

2254

"dayOfWeekValue": "A String", # day of week

2255

"stringValue": "A String", # string

2256

"booleanValue": True or False, # boolean

2257

"floatValue": 3.14, # float

2258

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2259

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2260

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2261

"day": 42, # 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.

2262

},

2263

"integerValue": "A String", # integer

2264

"timeValue": { # 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`. # time of day

2265

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2266

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2267

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2268

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2269

},

2270

},

2271

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

2272

"timestampValue": "A String", # timestamp

2273

"dayOfWeekValue": "A String", # day of week

2274

"stringValue": "A String", # string

2275

"booleanValue": True or False, # boolean

2276

"floatValue": 3.14, # float

2277

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2278

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2279

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2280

"day": 42, # 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.

2281

},

2282

"integerValue": "A String", # integer

2283

"timeValue": { # 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`. # time of day

2284

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2285

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2286

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2287

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2294

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2295

"timestampValue": "A String", # timestamp

2296

"dayOfWeekValue": "A String", # day of week

2297

"stringValue": "A String", # string

2298

"booleanValue": True or False, # boolean

2299

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2300

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2301

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2302

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2303

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2304

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2305

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2306

"timeValue": { # 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`. # time of day

2307

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2308

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2309

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2310

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2311

},

2312

},

2313

"lowerBound": { # 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. # Required. 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".

2314

"timestampValue": "A String", # timestamp

2315

"dayOfWeekValue": "A String", # day of week

2316

"stringValue": "A String", # string

2317

"booleanValue": True or False, # boolean

2318

"floatValue": 3.14, # float

2319

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2320

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2321

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2322

"day": 42, # 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.

2323

},

2324

"integerValue": "A String", # integer

2325

"timeValue": { # 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`. # time of day

2326

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2327

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2328

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2329

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2330

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2331

},

2332

"bucketSize": 3.14, # 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.

2333

},

2334

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

2335

"partToExtract": "A String", # The part of the time to keep.

2336

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2337

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

2338

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

2339

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2340

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2341

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2342

},

2343

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2344

"key": "A String", # Required. A 128/192/256 bit key.

2345

},

2346

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2347

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2348

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2349

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2350

},

2351

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2352

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

2353

"name": "A String", # Name describing the field.

2354

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2355

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

2356

"name": "A 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/dlp/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}`.

2357

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2358

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

2359

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2360

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2361

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2362

},

2363

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2364

"key": "A String", # Required. A 128/192/256 bit key.

2365

},

2366

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2367

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2368

},

2369

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

2370

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2371

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2372

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

2373

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2374

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2375

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2376

},

2377

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2378

"key": "A String", # Required. A 128/192/256 bit key.

2379

},

2380

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2381

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2382

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2383

},

2384

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2385

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

2386

"name": "A 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/dlp/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}`.

2387

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2388

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

2389

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

2390

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

2391

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2392

},

2393

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2394

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2395

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

2396

"name": "A String", # Name describing the field.

2397

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2398

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2399

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

2400

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2401

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2402

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2403

},

2404

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2405

"key": "A String", # Required. A 128/192/256 bit key.

2406

},

2407

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2408

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2409

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2410

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2411

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

2412

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2413

},

2414

"infoTypes": [ # 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`.

2415

{ # Type of information detected by the API.

2416

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2422

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

2423

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

2424

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

2425

"conditions": [ # A collection of conditions.

2426

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

2427

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

2428

"timestampValue": "A String", # timestamp

2429

"dayOfWeekValue": "A String", # day of week

2430

"stringValue": "A String", # string

2431

"booleanValue": True or False, # boolean

2432

"floatValue": 3.14, # float

2433

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2434

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2435

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2436

"day": 42, # 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.

2437

},

2438

"integerValue": "A String", # integer

2439

"timeValue": { # 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`. # time of day

2440

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2441

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2442

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2443

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2444

},

2445

},

2446

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

2447

"name": "A String", # Name describing the field.

2448

},

2449

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

2454

},

2455

},

2456

"fields": [ # Required. Input field(s) to apply the transformation to.

2457

{ # General identifier of a data field in a storage service.

2458

"name": "A String", # Name describing the field.

2459

},

2460

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2461

},

2462

],

2463

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

2464

{ # Configuration to suppress records whose suppression conditions evaluate to true.

2465

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

2466

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

2467

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

2468

"conditions": [ # A collection of conditions.

2469

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2470

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

2471

"timestampValue": "A String", # timestamp

2472

"dayOfWeekValue": "A String", # day of week

2473

"stringValue": "A String", # string

2474

"booleanValue": True or False, # boolean

2475

"floatValue": 3.14, # float

2476

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2477

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2478

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2479

"day": 42, # 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.

2480

},

2481

"integerValue": "A String", # integer

2482

"timeValue": { # 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`. # time of day

2483

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2484

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2485

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2486

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2487

},

2488

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2489

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

2490

"name": "A String", # Name describing the field.

2491

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2492

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2493

},

2494

],

2495

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2496

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2502

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2503

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

2504

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

2505

"description": "A String", # Short description (max 256 chars).

2506

"displayName": "A String", # Display name (max 256 chars).

2507

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

}</pre>

</div>

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2512

<code class="details" id="list">list(parent, pageSize=None, locationId=None, pageToken=None, orderBy=None, x__xgafv=None)</code>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2513

<pre>Lists DeidentifyTemplates. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2514

2515

Args:

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2516

parent: string, Required. Parent resource name. The format of this value varies depending on the scope of the request (project or organization) and whether you have [specified a processing location](https://cloud.google.com/dlp/docs/specifying-location): + Projects scope, location specified: `projects/`PROJECT_ID`/locations/`LOCATION_ID + Projects scope, no location specified (defaults to global): `projects/`PROJECT_ID + Organizations scope, location specified: `organizations/`ORG_ID`/locations/`LOCATION_ID + Organizations scope, no location specified (defaults to global): `organizations/`ORG_ID The following example `parent` string specifies a parent project with the identifier `example-project`, and specifies the `europe-west3` location for processing data: parent=projects/example-project/locations/europe-west3 (required)

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2517

pageSize: integer, Size of the page, can be limited by server. If zero server returns a page of max size 100.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2518

locationId: string, Deprecated. This field has no effect.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2519

pageToken: string, Page token to continue retrieval. Comes from previous call to `ListDeidentifyTemplates`.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2520

orderBy: string, Comma separated list of fields to order by, followed by `asc` or `desc` postfix. This list is case-insensitive, default sorting order is ascending, redundant space characters are insignificant. Example: `name asc,update_time, create_time desc` Supported fields are: - `create_time`: corresponds to time the template was created. - `update_time`: corresponds to time the template was last updated. - `name`: corresponds to template's name. - `display_name`: corresponds to template's display name.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2521

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

An object of the form:

2528

2529

{ # Response message for ListDeidentifyTemplates.

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2530

"deidentifyTemplates": [ # List of deidentify templates, up to page_size in ListDeidentifyTemplatesRequest.

2531

{ # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more.

2532

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2533

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

2534

"leaveUntransformed": { # 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. # Ignore errors

2535

},

2536

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

2537

},

2538

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2539

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

2540

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

2541

{ # A transformation to apply to text that is identified as a specific info_type.

2542

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2543

"redactConfig": { # 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 '. # Redact

2544

},

2545

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

2546

"newValue": { # 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. # Value to replace it with.

2547

"timestampValue": "A String", # timestamp

2548

"dayOfWeekValue": "A String", # day of week

2549

"stringValue": "A String", # string

2550

"booleanValue": True or False, # boolean

2551

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2552

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2553

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2554

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2555

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2556

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2557

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2558

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2559

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2560

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2561

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2562

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2563

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2564

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2565

},

2566

"characterMaskConfig": { # 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. # Mask

2567

"maskingCharacter": "A 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.

2568

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

2569

"reverseOrder": True or False, # 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***`.

2570

"charactersToIgnore": [ # 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`.

2571

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

2572

"charactersToSkip": "A String", # Characters to not transform when masking.

2573

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

2578

},

2579

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

2580

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

2581

{ # Bucket is represented as a range, along with replacement values.

2582

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

2583

"timestampValue": "A String", # timestamp

2584

"dayOfWeekValue": "A String", # day of week

2585

"stringValue": "A String", # string

2586

"booleanValue": True or False, # boolean

2587

"floatValue": 3.14, # float

2588

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2589

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2590

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2591

"day": 42, # 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.

2592

},

2593

"integerValue": "A String", # integer

2594

"timeValue": { # 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`. # time of day

2595

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2596

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2597

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2598

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2599

},

2600

},

2601

"replacementValue": { # 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. # Required. Replacement value for this bucket.

2602

"timestampValue": "A String", # timestamp

2603

"dayOfWeekValue": "A String", # day of week

2604

"stringValue": "A String", # string

2605

"booleanValue": True or False, # boolean

2606

"floatValue": 3.14, # float

2607

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2608

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2609

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2610

"day": 42, # 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.

2611

},

2612

"integerValue": "A String", # integer

2613

"timeValue": { # 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`. # time of day

2614

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2615

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2616

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2617

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2618

},

2619

},

2620

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

2621

"timestampValue": "A String", # timestamp

2622

"dayOfWeekValue": "A String", # day of week

2623

"stringValue": "A String", # string

2624

"booleanValue": True or False, # boolean

2625

"floatValue": 3.14, # float

2626

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2627

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2628

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2629

"day": 42, # 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.

2630

},

2631

"integerValue": "A String", # integer

2632

"timeValue": { # 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`. # time of day

2633

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2634

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2635

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2636

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2643

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2644

"timestampValue": "A String", # timestamp

2645

"dayOfWeekValue": "A String", # day of week

2646

"stringValue": "A String", # string

2647

"booleanValue": True or False, # boolean

2648

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2649

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2650

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2651

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2652

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2653

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2654

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2655

"timeValue": { # 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`. # time of day

2656

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2657

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2658

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2659

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2660

},

2661

},

2662

"lowerBound": { # 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. # Required. 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".

2663

"timestampValue": "A String", # timestamp

2664

"dayOfWeekValue": "A String", # day of week

2665

"stringValue": "A String", # string

2666

"booleanValue": True or False, # boolean

2667

"floatValue": 3.14, # float

2668

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2669

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2670

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2671

"day": 42, # 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.

2672

},

2673

"integerValue": "A String", # integer

2674

"timeValue": { # 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`. # time of day

2675

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2676

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2677

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2678

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2679

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2680

},

2681

"bucketSize": 3.14, # 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.

2682

},

2683

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

2684

"partToExtract": "A String", # The part of the time to keep.

2685

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2686

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

2687

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

2688

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2689

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2690

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2691

},

2692

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2693

"key": "A String", # Required. A 128/192/256 bit key.

2694

},

2695

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2696

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2697

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2698

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2699

},

2700

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

2701

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

2702

"name": "A String", # Name describing the field.

2703

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2704

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

2705

"name": "A 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/dlp/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}`.

2706

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2707

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

2708

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2709

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2710

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2711

},

2712

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2713

"key": "A String", # Required. A 128/192/256 bit key.

2714

},

2715

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2716

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2717

},

2718

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

2719

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2720

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2721

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

2722

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2723

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2724

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2725

},

2726

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2727

"key": "A String", # Required. A 128/192/256 bit key.

2728

},

2729

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2730

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2731

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2732

},

2733

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2734

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

2735

"name": "A 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/dlp/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}`.

2736

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2737

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

2738

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

2739

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

2740

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2741

},

2742

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2743

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2744

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

2745

"name": "A String", # Name describing the field.

2746

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2747

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2748

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

2749

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2750

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2751

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2752

},

2753

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2754

"key": "A String", # Required. A 128/192/256 bit key.

2755

},

2756

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2757

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2758

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

2759

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2760

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

2761

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

2762

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2763

"infoTypes": [ # 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`.

2764

{ # Type of information detected by the API.

2765

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2771

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

2772

"fieldTransformations": [ # Transform the record by applying various field transformations.

2773

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2774

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

2775

"redactConfig": { # 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 '. # Redact

2776

},

2777

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

2778

"newValue": { # 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. # Value to replace it with.

2779

"timestampValue": "A String", # timestamp

2780

"dayOfWeekValue": "A String", # day of week

2781

"stringValue": "A String", # string

2782

"booleanValue": True or False, # boolean

2783

"floatValue": 3.14, # float

2784

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2785

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2786

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2787

"day": 42, # 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.

2788

},

2789

"integerValue": "A String", # integer

2790

"timeValue": { # 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`. # time of day

2791

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2792

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2793

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2794

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

2799

"maskingCharacter": "A 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.

2800

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

2801

"reverseOrder": True or False, # 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***`.

2802

"charactersToIgnore": [ # 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`.

2803

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

2804

"charactersToSkip": "A String", # Characters to not transform when masking.

2805

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

2810

},

2811

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

2812

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

2813

{ # Bucket is represented as a range, along with replacement values.

2814

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

2815

"timestampValue": "A String", # timestamp

2816

"dayOfWeekValue": "A String", # day of week

2817

"stringValue": "A String", # string

2818

"booleanValue": True or False, # boolean

2819

"floatValue": 3.14, # float

2820

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2821

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2822

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2823

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2824

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2825

"integerValue": "A String", # integer

2826

"timeValue": { # 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`. # time of day

2827

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2828

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2829

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2830

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2831

},

2832

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2833

"replacementValue": { # 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. # Required. Replacement value for this bucket.

2834

"timestampValue": "A String", # timestamp

2835

"dayOfWeekValue": "A String", # day of week

2836

"stringValue": "A String", # string

2837

"booleanValue": True or False, # boolean

2838

"floatValue": 3.14, # float

2839

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2840

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2841

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2842

"day": 42, # 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.

2843

},

2844

"integerValue": "A String", # integer

2845

"timeValue": { # 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`. # time of day

2846

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2847

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2848

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2849

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

2850

},

2851

},

2852

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

2853

"timestampValue": "A String", # timestamp

2854

"dayOfWeekValue": "A String", # day of week

2855

"stringValue": "A String", # string

2856

"booleanValue": True or False, # boolean

2857

"floatValue": 3.14, # float

2858

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2859

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

2860

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

2861

"day": 42, # 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.

2862

},

2863

"integerValue": "A String", # integer

2864

"timeValue": { # 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`. # time of day

2865

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

2866

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

2867

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2868

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2873

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2874

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2875

"upperBound": { # 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. # Required. 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+".

2876

"timestampValue": "A String", # timestamp

2877

"dayOfWeekValue": "A String", # day of week

2878

"stringValue": "A String", # string

2879

"booleanValue": True or False, # boolean

2880

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2881

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2882

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2883

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2884

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2885

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2886

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2887

"timeValue": { # 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`. # time of day

2888

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2889

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2890

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2891

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2892

},

2893

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2894

"lowerBound": { # 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. # Required. 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".

2895

"timestampValue": "A String", # timestamp

2896

"dayOfWeekValue": "A String", # day of week

2897

"stringValue": "A String", # string

2898

"booleanValue": True or False, # boolean

2899

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2900

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

2901

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2902

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2903

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2904

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2905

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2906

"timeValue": { # 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`. # time of day

2907

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2908

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2909

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

2910

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2911

},

2912

},

2913

"bucketSize": 3.14, # 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.

2914

},

2915

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

2916

"partToExtract": "A String", # The part of the time to keep.

2917

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2918

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

2919

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

2920

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2921

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2922

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2923

},

2924

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2925

"key": "A String", # Required. A 128/192/256 bit key.

2926

},

2927

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2928

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2929

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2930

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2931

},

2932

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2933

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

2934

"name": "A String", # Name describing the field.

2935

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2936

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

2937

"name": "A 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/dlp/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}`.

2938

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2939

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

2940

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2941

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2942

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2943

},

2944

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2945

"key": "A String", # Required. A 128/192/256 bit key.

2946

},

2947

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2948

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2953

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

2954

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

2955

"wrappedKey": "A String", # Required. The wrapped data crypto key.

2956

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

2957

},

2958

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2959

"key": "A String", # Required. A 128/192/256 bit key.

2960

},

2961

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2962

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2963

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2964

},

2965

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2966

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

2967

"name": "A 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/dlp/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}`.

2968

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2969

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

2970

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

2971

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

2972

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2973

},

2974

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2975

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2976

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

2977

"name": "A String", # Name describing the field.

2978

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2979

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2980

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

2981

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2982

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2983

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2984

},

2985

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

2986

"key": "A String", # Required. A 128/192/256 bit key.

2987

},

2988

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

2989

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

2990

},

2991

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2992

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

2993

},

2994

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

2995

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

2996

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

2997

{ # A transformation to apply to text that is identified as a specific info_type.

2998

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

2999

"redactConfig": { # 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 '. # Redact

3000

},

3001

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

3002

"newValue": { # 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. # Value to replace it with.

3003

"timestampValue": "A String", # timestamp

3004

"dayOfWeekValue": "A String", # day of week

3005

"stringValue": "A String", # string

3006

"booleanValue": True or False, # boolean

3007

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3008

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3009

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3010

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3011

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3012

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3013

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3014

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3015

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3016

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3017

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3018

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3019

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3020

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3021

},

3022

"characterMaskConfig": { # 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. # Mask

3023

"maskingCharacter": "A 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.

3024

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

3025

"reverseOrder": True or False, # 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***`.

3026

"charactersToIgnore": [ # 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`.

3027

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

3028

"charactersToSkip": "A String", # Characters to not transform when masking.

3029

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

3034

},

3035

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

3036

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

3037

{ # Bucket is represented as a range, along with replacement values.

3038

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

3039

"timestampValue": "A String", # timestamp

3040

"dayOfWeekValue": "A String", # day of week

3041

"stringValue": "A String", # string

3042

"booleanValue": True or False, # boolean

3043

"floatValue": 3.14, # float

3044

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3045

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3046

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3047

"day": 42, # 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.

3048

},

3049

"integerValue": "A String", # integer

3050

"timeValue": { # 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`. # time of day

3051

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3052

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3053

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3054

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3055

},

3056

},

3057

"replacementValue": { # 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. # Required. Replacement value for this bucket.

3058

"timestampValue": "A String", # timestamp

3059

"dayOfWeekValue": "A String", # day of week

3060

"stringValue": "A String", # string

3061

"booleanValue": True or False, # boolean

3062

"floatValue": 3.14, # float

3063

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3064

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3065

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3066

"day": 42, # 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.

3067

},

3068

"integerValue": "A String", # integer

3069

"timeValue": { # 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`. # time of day

3070

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3071

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3072

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3073

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3074

},

3075

},

3076

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

3077

"timestampValue": "A String", # timestamp

3078

"dayOfWeekValue": "A String", # day of week

3079

"stringValue": "A String", # string

3080

"booleanValue": True or False, # boolean

3081

"floatValue": 3.14, # float

3082

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3083

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3084

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3085

"day": 42, # 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.

3086

},

3087

"integerValue": "A String", # integer

3088

"timeValue": { # 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`. # time of day

3089

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3090

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3091

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3092

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3099

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3100

"timestampValue": "A String", # timestamp

3101

"dayOfWeekValue": "A String", # day of week

3102

"stringValue": "A String", # string

3103

"booleanValue": True or False, # boolean

3104

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3105

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3106

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3107

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3108

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3109

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3110

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3111

"timeValue": { # 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`. # time of day

3112

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3113

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3114

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3115

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3116

},

3117

},

3118

"lowerBound": { # 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. # Required. 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".

3119

"timestampValue": "A String", # timestamp

3120

"dayOfWeekValue": "A String", # day of week

3121

"stringValue": "A String", # string

3122

"booleanValue": True or False, # boolean

3123

"floatValue": 3.14, # float

3124

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3125

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3126

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3127

"day": 42, # 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.

3128

},

3129

"integerValue": "A String", # integer

3130

"timeValue": { # 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`. # time of day

3131

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3132

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3133

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3134

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3135

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3136

},

3137

"bucketSize": 3.14, # 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.

3138

},

3139

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

3140

"partToExtract": "A String", # The part of the time to keep.

3141

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3142

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

3143

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

3144

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3145

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3146

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3147

},

3148

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3149

"key": "A String", # Required. A 128/192/256 bit key.

3150

},

3151

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3152

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3153

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3154

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3155

},

3156

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3157

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

3158

"name": "A String", # Name describing the field.

3159

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3160

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

3161

"name": "A 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/dlp/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}`.

3162

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3163

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

3164

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3165

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3166

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3167

},

3168

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3169

"key": "A String", # Required. A 128/192/256 bit key.

3170

},

3171

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3172

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3173

},

3174

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

3175

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3176

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3177

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

3178

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3179

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3180

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3181

},

3182

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3183

"key": "A String", # Required. A 128/192/256 bit key.

3184

},

3185

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3186

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3187

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3188

},

3189

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3190

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

3191

"name": "A 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/dlp/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}`.

3192

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3193

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

3194

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

3195

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

3196

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3197

},

3198

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3199

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3200

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

3201

"name": "A String", # Name describing the field.

3202

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3203

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3204

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

3205

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3206

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3207

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3208

},

3209

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3210

"key": "A String", # Required. A 128/192/256 bit key.

3211

},

3212

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3213

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3214

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3215

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3216

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

3217

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

3218

},

3219

"infoTypes": [ # 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`.

3220

{ # Type of information detected by the API.

3221

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3227

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

3228

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

3229

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

3230

"conditions": [ # A collection of conditions.

3231

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

3232

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

3233

"timestampValue": "A String", # timestamp

3234

"dayOfWeekValue": "A String", # day of week

3235

"stringValue": "A String", # string

3236

"booleanValue": True or False, # boolean

3237

"floatValue": 3.14, # float

3238

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3239

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3240

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3241

"day": 42, # 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.

3242

},

3243

"integerValue": "A String", # integer

3244

"timeValue": { # 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`. # time of day

3245

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3246

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3247

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3248

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3249

},

3250

},

3251

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

3252

"name": "A String", # Name describing the field.

3253

},

3254

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

3259

},

3260

},

3261

"fields": [ # Required. Input field(s) to apply the transformation to.

3262

{ # General identifier of a data field in a storage service.

3263

"name": "A String", # Name describing the field.

3264

},

3265

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3266

},

3267

],

3268

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

3269

{ # Configuration to suppress records whose suppression conditions evaluate to true.

3270

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

3271

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

3272

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

3273

"conditions": [ # A collection of conditions.

3274

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3275

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

3276

"timestampValue": "A String", # timestamp

3277

"dayOfWeekValue": "A String", # day of week

3278

"stringValue": "A String", # string

3279

"booleanValue": True or False, # boolean

3280

"floatValue": 3.14, # float

3281

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3282

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3283

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3284

"day": 42, # 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.

3285

},

3286

"integerValue": "A String", # integer

3287

"timeValue": { # 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`. # time of day

3288

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3289

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3290

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3291

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3292

},

3293

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3294

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

3295

"name": "A String", # Name describing the field.

3296

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3297

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3298

},

3299

],

3300

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3301

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3307

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3308

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

3309

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

3310

"description": "A String", # Short description (max 256 chars).

3311

"displayName": "A String", # Display name (max 256 chars).

3312

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3313

},

3314

],

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3315

"nextPageToken": "A String", # If the next page is available then the next page token to be used in following ListDeidentifyTemplates request.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

}</pre>

</div>

<code class="details" id="list_next">list_next(previous_request, previous_response)</code>

3321

<pre>Retrieves the next page of results.

3322

3323

Args:

3324

previous_request: The request for the previous page. (required)

3325

previous_response: The response from the request for the previous page. (required)

3326

3327

Returns:

3328

A request object that you can call 'execute()' on to request the next

3329

page. Returns None if there are no more items in the collection.

</pre>

</div>

<code class="details" id="patch">patch(name, body=None, x__xgafv=None)</code>

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

3335

<pre>Updates the DeidentifyTemplate. See https://cloud.google.com/dlp/docs/creating-templates-deid to learn more.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3336

3337

Args:

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

3338

name: string, Required. Resource name of organization and deidentify template to be updated, for example `organizations/433245324/deidentifyTemplates/432452342` or projects/project-id/deidentifyTemplates/432452342. (required)

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3339

body: object, The request body.

3340

The object takes the form of:

3341

3342

{ # Request message for UpdateDeidentifyTemplate.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3343

"updateMask": "A String", # Mask to control which fields get updated.

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

3344

"deidentifyTemplate": { # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more. # New DeidentifyTemplate value.

3345

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3346

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

3347

"leaveUntransformed": { # 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. # Ignore errors

3348

},

3349

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

3350

},

3351

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3352

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

3353

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

3354

{ # A transformation to apply to text that is identified as a specific info_type.

3355

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3356

"redactConfig": { # 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 '. # Redact

3357

},

3358

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

3359

"newValue": { # 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. # Value to replace it with.

3360

"timestampValue": "A String", # timestamp

3361

"dayOfWeekValue": "A String", # day of week

3362

"stringValue": "A String", # string

3363

"booleanValue": True or False, # boolean

3364

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3365

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3366

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3367

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3368

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3369

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3370

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3371

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3372

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3373

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3374

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3375

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3376

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3377

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3378

},

3379

"characterMaskConfig": { # 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. # Mask

3380

"maskingCharacter": "A 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.

3381

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

3382

"reverseOrder": True or False, # 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***`.

3383

"charactersToIgnore": [ # 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`.

3384

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

3385

"charactersToSkip": "A String", # Characters to not transform when masking.

3386

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

3391

},

3392

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

3393

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

3394

{ # Bucket is represented as a range, along with replacement values.

3395

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

3396

"timestampValue": "A String", # timestamp

3397

"dayOfWeekValue": "A String", # day of week

3398

"stringValue": "A String", # string

3399

"booleanValue": True or False, # boolean

3400

"floatValue": 3.14, # float

3401

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3402

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3403

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3404

"day": 42, # 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.

3405

},

3406

"integerValue": "A String", # integer

3407

"timeValue": { # 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`. # time of day

3408

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3409

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3410

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3411

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3412

},

3413

},

3414

"replacementValue": { # 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. # Required. Replacement value for this bucket.

3415

"timestampValue": "A String", # timestamp

3416

"dayOfWeekValue": "A String", # day of week

3417

"stringValue": "A String", # string

3418

"booleanValue": True or False, # boolean

3419

"floatValue": 3.14, # float

3420

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3421

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3422

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3423

"day": 42, # 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.

3424

},

3425

"integerValue": "A String", # integer

3426

"timeValue": { # 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`. # time of day

3427

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3428

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3429

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3430

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3431

},

3432

},

3433

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

3434

"timestampValue": "A String", # timestamp

3435

"dayOfWeekValue": "A String", # day of week

3436

"stringValue": "A String", # string

3437

"booleanValue": True or False, # boolean

3438

"floatValue": 3.14, # float

3439

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3440

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3441

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3442

"day": 42, # 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.

3443

},

3444

"integerValue": "A String", # integer

3445

"timeValue": { # 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`. # time of day

3446

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3447

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3448

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3449

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3456

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3457

"timestampValue": "A String", # timestamp

3458

"dayOfWeekValue": "A String", # day of week

3459

"stringValue": "A String", # string

3460

"booleanValue": True or False, # boolean

3461

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3462

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3463

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3464

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3465

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3466

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3467

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3468

"timeValue": { # 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`. # time of day

3469

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3470

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3471

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3472

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3473

},

3474

},

3475

"lowerBound": { # 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. # Required. 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".

3476

"timestampValue": "A String", # timestamp

3477

"dayOfWeekValue": "A String", # day of week

3478

"stringValue": "A String", # string

3479

"booleanValue": True or False, # boolean

3480

"floatValue": 3.14, # float

3481

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3482

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3483

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3484

"day": 42, # 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.

3485

},

3486

"integerValue": "A String", # integer

3487

"timeValue": { # 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`. # time of day

3488

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3489

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3490

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3491

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3492

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3493

},

3494

"bucketSize": 3.14, # 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.

3495

},

3496

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

3497

"partToExtract": "A String", # The part of the time to keep.

3498

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3499

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

3500

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

3501

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3502

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3503

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3504

},

3505

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3506

"key": "A String", # Required. A 128/192/256 bit key.

3507

},

3508

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3509

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3510

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3511

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3512

},

3513

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3514

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

3515

"name": "A String", # Name describing the field.

3516

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3517

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

3518

"name": "A 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/dlp/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}`.

3519

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3520

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

3521

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3522

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3523

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3524

},

3525

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3526

"key": "A String", # Required. A 128/192/256 bit key.

3527

},

3528

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3529

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3530

},

3531

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

3532

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3533

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3534

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

3535

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3536

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3537

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3538

},

3539

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3540

"key": "A String", # Required. A 128/192/256 bit key.

3541

},

3542

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3543

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3544

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3545

},

3546

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3547

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

3548

"name": "A 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/dlp/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}`.

3549

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3550

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

3551

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

3552

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

3553

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3554

},

3555

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3556

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3557

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

3558

"name": "A String", # Name describing the field.

3559

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3560

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3561

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

3562

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3563

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3564

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3565

},

3566

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3567

"key": "A String", # Required. A 128/192/256 bit key.

3568

},

3569

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3570

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3571

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3572

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3573

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

3574

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

3575

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3576

"infoTypes": [ # 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`.

3577

{ # Type of information detected by the API.

3578

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3584

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

3585

"fieldTransformations": [ # Transform the record by applying various field transformations.

3586

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3587

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

3588

"redactConfig": { # 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 '. # Redact

3589

},

3590

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

3591

"newValue": { # 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. # Value to replace it with.

3592

"timestampValue": "A String", # timestamp

3593

"dayOfWeekValue": "A String", # day of week

3594

"stringValue": "A String", # string

3595

"booleanValue": True or False, # boolean

3596

"floatValue": 3.14, # float

3597

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3598

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3599

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3600

"day": 42, # 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.

3601

},

3602

"integerValue": "A String", # integer

3603

"timeValue": { # 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`. # time of day

3604

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3605

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3606

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3607

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

3612

"maskingCharacter": "A 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.

3613

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

3614

"reverseOrder": True or False, # 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***`.

3615

"charactersToIgnore": [ # 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`.

3616

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

3617

"charactersToSkip": "A String", # Characters to not transform when masking.

3618

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

3623

},

3624

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

3625

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

3626

{ # Bucket is represented as a range, along with replacement values.

3627

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

3628

"timestampValue": "A String", # timestamp

3629

"dayOfWeekValue": "A String", # day of week

3630

"stringValue": "A String", # string

3631

"booleanValue": True or False, # boolean

3632

"floatValue": 3.14, # float

3633

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3634

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3635

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3636

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3637

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3638

"integerValue": "A String", # integer

3639

"timeValue": { # 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`. # time of day

3640

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3641

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3642

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3643

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3644

},

3645

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3646

"replacementValue": { # 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. # Required. Replacement value for this bucket.

3647

"timestampValue": "A String", # timestamp

3648

"dayOfWeekValue": "A String", # day of week

3649

"stringValue": "A String", # string

3650

"booleanValue": True or False, # boolean

3651

"floatValue": 3.14, # float

3652

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3653

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3654

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3655

"day": 42, # 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.

3656

},

3657

"integerValue": "A String", # integer

3658

"timeValue": { # 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`. # time of day

3659

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3660

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3661

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3662

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3663

},

3664

},

3665

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

3666

"timestampValue": "A String", # timestamp

3667

"dayOfWeekValue": "A String", # day of week

3668

"stringValue": "A String", # string

3669

"booleanValue": True or False, # boolean

3670

"floatValue": 3.14, # float

3671

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3672

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3673

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3674

"day": 42, # 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.

3675

},

3676

"integerValue": "A String", # integer

3677

"timeValue": { # 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`. # time of day

3678

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3679

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3680

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3681

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3686

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3687

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3688

"upperBound": { # 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. # Required. 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+".

3689

"timestampValue": "A String", # timestamp

3690

"dayOfWeekValue": "A String", # day of week

3691

"stringValue": "A String", # string

3692

"booleanValue": True or False, # boolean

3693

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3694

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3695

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3696

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3697

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3698

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3699

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3700

"timeValue": { # 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`. # time of day

3701

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3702

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3703

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3704

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3705

},

3706

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3707

"lowerBound": { # 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. # Required. 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".

3708

"timestampValue": "A String", # timestamp

3709

"dayOfWeekValue": "A String", # day of week

3710

"stringValue": "A String", # string

3711

"booleanValue": True or False, # boolean

3712

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3713

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3714

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3715

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3716

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3717

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3718

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3719

"timeValue": { # 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`. # time of day

3720

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3721

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3722

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3723

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3724

},

3725

},

3726

"bucketSize": 3.14, # 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.

3727

},

3728

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

3729

"partToExtract": "A String", # The part of the time to keep.

3730

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3731

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

3732

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

3733

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3734

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3735

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3736

},

3737

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3738

"key": "A String", # Required. A 128/192/256 bit key.

3739

},

3740

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3741

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3742

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3743

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3744

},

3745

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3746

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

3747

"name": "A String", # Name describing the field.

3748

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3749

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

3750

"name": "A 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/dlp/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}`.

3751

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3752

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

3753

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3754

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3755

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3756

},

3757

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3758

"key": "A String", # Required. A 128/192/256 bit key.

3759

},

3760

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3761

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3766

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

3767

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3768

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3769

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3770

},

3771

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3772

"key": "A String", # Required. A 128/192/256 bit key.

3773

},

3774

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3775

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3776

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3777

},

3778

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3779

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

3780

"name": "A 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/dlp/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}`.

3781

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3782

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

3783

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

3784

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

3785

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3786

},

3787

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3788

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3789

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

3790

"name": "A String", # Name describing the field.

3791

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3792

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3793

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

3794

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3795

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3796

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3797

},

3798

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3799

"key": "A String", # Required. A 128/192/256 bit key.

3800

},

3801

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3802

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3803

},

3804

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3805

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3806

},

3807

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

3808

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

3809

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

3810

{ # A transformation to apply to text that is identified as a specific info_type.

3811

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3812

"redactConfig": { # 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 '. # Redact

3813

},

3814

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

3815

"newValue": { # 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. # Value to replace it with.

3816

"timestampValue": "A String", # timestamp

3817

"dayOfWeekValue": "A String", # day of week

3818

"stringValue": "A String", # string

3819

"booleanValue": True or False, # boolean

3820

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3821

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3822

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3823

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3824

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3825

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3826

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3827

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3828

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3829

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3830

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3831

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3832

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3833

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3834

},

3835

"characterMaskConfig": { # 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. # Mask

3836

"maskingCharacter": "A 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.

3837

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

3838

"reverseOrder": True or False, # 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***`.

3839

"charactersToIgnore": [ # 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`.

3840

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

3841

"charactersToSkip": "A String", # Characters to not transform when masking.

3842

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

3847

},

3848

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

3849

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

3850

{ # Bucket is represented as a range, along with replacement values.

3851

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

3852

"timestampValue": "A String", # timestamp

3853

"dayOfWeekValue": "A String", # day of week

3854

"stringValue": "A String", # string

3855

"booleanValue": True or False, # boolean

3856

"floatValue": 3.14, # float

3857

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3858

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3859

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3860

"day": 42, # 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.

3861

},

3862

"integerValue": "A String", # integer

3863

"timeValue": { # 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`. # time of day

3864

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3865

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3866

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3867

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3868

},

3869

},

3870

"replacementValue": { # 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. # Required. Replacement value for this bucket.

3871

"timestampValue": "A String", # timestamp

3872

"dayOfWeekValue": "A String", # day of week

3873

"stringValue": "A String", # string

3874

"booleanValue": True or False, # boolean

3875

"floatValue": 3.14, # float

3876

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3877

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3878

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3879

"day": 42, # 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.

3880

},

3881

"integerValue": "A String", # integer

3882

"timeValue": { # 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`. # time of day

3883

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3884

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3885

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3886

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

3887

},

3888

},

3889

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

3890

"timestampValue": "A String", # timestamp

3891

"dayOfWeekValue": "A String", # day of week

3892

"stringValue": "A String", # string

3893

"booleanValue": True or False, # boolean

3894

"floatValue": 3.14, # float

3895

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3896

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3897

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3898

"day": 42, # 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.

3899

},

3900

"integerValue": "A String", # integer

3901

"timeValue": { # 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`. # time of day

3902

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

3903

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

3904

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3905

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3912

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3913

"timestampValue": "A String", # timestamp

3914

"dayOfWeekValue": "A String", # day of week

3915

"stringValue": "A String", # string

3916

"booleanValue": True or False, # boolean

3917

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3918

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3919

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3920

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3921

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3922

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3923

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3924

"timeValue": { # 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`. # time of day

3925

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3926

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3927

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3928

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3929

},

3930

},

3931

"lowerBound": { # 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. # Required. 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".

3932

"timestampValue": "A String", # timestamp

3933

"dayOfWeekValue": "A String", # day of week

3934

"stringValue": "A String", # string

3935

"booleanValue": True or False, # boolean

3936

"floatValue": 3.14, # float

3937

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

3938

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

3939

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

3940

"day": 42, # 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.

3941

},

3942

"integerValue": "A String", # integer

3943

"timeValue": { # 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`. # time of day

3944

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3945

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3946

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

3947

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3948

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3949

},

3950

"bucketSize": 3.14, # 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.

3951

},

3952

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

3953

"partToExtract": "A String", # The part of the time to keep.

3954

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3955

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

3956

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

3957

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3958

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3959

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3960

},

3961

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3962

"key": "A String", # Required. A 128/192/256 bit key.

3963

},

3964

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3965

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3966

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3967

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3968

},

3969

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

3970

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

3971

"name": "A String", # Name describing the field.

3972

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3973

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

3974

"name": "A 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/dlp/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}`.

3975

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3976

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

3977

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3978

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3979

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

3980

},

3981

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3982

"key": "A String", # Required. A 128/192/256 bit key.

3983

},

3984

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3985

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

3986

},

3987

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

3988

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

3989

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

3990

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

3991

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

3992

"wrappedKey": "A String", # Required. The wrapped data crypto key.

3993

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

3994

},

3995

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

3996

"key": "A String", # Required. A 128/192/256 bit key.

3997

},

3998

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

3999

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4000

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4001

},

4002

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4003

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

4004

"name": "A 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/dlp/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}`.

4005

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4006

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

4007

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

4008

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

4009

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4010

},

4011

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4012

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4013

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

4014

"name": "A String", # Name describing the field.

4015

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4016

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4017

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

4018

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4019

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4020

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4021

},

4022

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4023

"key": "A String", # Required. A 128/192/256 bit key.

4024

},

4025

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4026

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4027

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4028

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4029

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

4030

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

4031

},

4032

"infoTypes": [ # 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`.

4033

{ # Type of information detected by the API.

4034

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4040

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

4041

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

4042

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

4043

"conditions": [ # A collection of conditions.

4044

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

4045

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

4046

"timestampValue": "A String", # timestamp

4047

"dayOfWeekValue": "A String", # day of week

4048

"stringValue": "A String", # string

4049

"booleanValue": True or False, # boolean

4050

"floatValue": 3.14, # float

4051

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4052

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4053

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4054

"day": 42, # 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.

4055

},

4056

"integerValue": "A String", # integer

4057

"timeValue": { # 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`. # time of day

4058

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4059

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4060

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4061

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4062

},

4063

},

4064

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

4065

"name": "A String", # Name describing the field.

4066

},

4067

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

4072

},

4073

},

4074

"fields": [ # Required. Input field(s) to apply the transformation to.

4075

{ # General identifier of a data field in a storage service.

4076

"name": "A String", # Name describing the field.

4077

},

4078

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4079

},

4080

],

4081

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

4082

{ # Configuration to suppress records whose suppression conditions evaluate to true.

4083

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

4084

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

4085

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

4086

"conditions": [ # A collection of conditions.

4087

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4088

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

4089

"timestampValue": "A String", # timestamp

4090

"dayOfWeekValue": "A String", # day of week

4091

"stringValue": "A String", # string

4092

"booleanValue": True or False, # boolean

4093

"floatValue": 3.14, # float

4094

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4095

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4096

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4097

"day": 42, # 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.

4098

},

4099

"integerValue": "A String", # integer

4100

"timeValue": { # 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`. # time of day

4101

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4102

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4103

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4104

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4105

},

4106

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4107

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

4108

"name": "A String", # Name describing the field.

4109

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4110

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4111

},

4112

],

4113

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4114

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

4120

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4121

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

4122

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

4123

"description": "A String", # Short description (max 256 chars).

4124

"displayName": "A String", # Display name (max 256 chars).

4125

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

4126

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

4127

}

4128

4129

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

An object of the form:

4136

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

4137

{ # DeidentifyTemplates contains instructions on how to de-identify content. See https://cloud.google.com/dlp/docs/concepts-templates to learn more.

4138

"deidentifyConfig": { # The configuration that controls how the data will change. # ///////////// // The core content of the template // ///////////////

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4139

"transformationErrorHandling": { # 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`. # Mode for handling transformation errors. If left unspecified, the default mode is `TransformationErrorHandling.ThrowError`.

4140

"leaveUntransformed": { # 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. # Ignore errors

4141

},

4142

"throwError": { # Throw an error and fail the request when a transformation error occurs. # Throw an error

4143

},

4144

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4145

"infoTypeTransformations": { # 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. # Treat the dataset as free-form text and apply the same free text transformation everywhere.

4146

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

4147

{ # A transformation to apply to text that is identified as a specific info_type.

4148

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4149

"redactConfig": { # 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 '. # Redact

4150

},

4151

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

4152

"newValue": { # 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. # Value to replace it with.

4153

"timestampValue": "A String", # timestamp

4154

"dayOfWeekValue": "A String", # day of week

4155

"stringValue": "A String", # string

4156

"booleanValue": True or False, # boolean

4157

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4158

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4159

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4160

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4161

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4162

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4163

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4164

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4165

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4166

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4167

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4168

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4169

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4170

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4171

},

4172

"characterMaskConfig": { # 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. # Mask

4173

"maskingCharacter": "A 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.

4174

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

4175

"reverseOrder": True or False, # 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***`.

4176

"charactersToIgnore": [ # 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`.

4177

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

4178

"charactersToSkip": "A String", # Characters to not transform when masking.

4179

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

4184

},

4185

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

4186

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

4187

{ # Bucket is represented as a range, along with replacement values.

4188

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

4189

"timestampValue": "A String", # timestamp

4190

"dayOfWeekValue": "A String", # day of week

4191

"stringValue": "A String", # string

4192

"booleanValue": True or False, # boolean

4193

"floatValue": 3.14, # float

4194

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4195

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4196

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4197

"day": 42, # 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.

4198

},

4199

"integerValue": "A String", # integer

4200

"timeValue": { # 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`. # time of day

4201

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4202

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4203

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4204

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4205

},

4206

},

4207

"replacementValue": { # 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. # Required. Replacement value for this bucket.

4208

"timestampValue": "A String", # timestamp

4209

"dayOfWeekValue": "A String", # day of week

4210

"stringValue": "A String", # string

4211

"booleanValue": True or False, # boolean

4212

"floatValue": 3.14, # float

4213

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4214

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4215

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4216

"day": 42, # 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.

4217

},

4218

"integerValue": "A String", # integer

4219

"timeValue": { # 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`. # time of day

4220

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4221

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4222

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4223

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4224

},

4225

},

4226

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

4227

"timestampValue": "A String", # timestamp

4228

"dayOfWeekValue": "A String", # day of week

4229

"stringValue": "A String", # string

4230

"booleanValue": True or False, # boolean

4231

"floatValue": 3.14, # float

4232

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4233

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4234

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4235

"day": 42, # 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.

4236

},

4237

"integerValue": "A String", # integer

4238

"timeValue": { # 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`. # time of day

4239

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4240

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4241

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4242

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4249

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4250

"timestampValue": "A String", # timestamp

4251

"dayOfWeekValue": "A String", # day of week

4252

"stringValue": "A String", # string

4253

"booleanValue": True or False, # boolean

4254

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4255

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4256

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4257

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4258

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4259

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4260

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4261

"timeValue": { # 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`. # time of day

4262

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4263

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4264

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4265

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4266

},

4267

},

4268

"lowerBound": { # 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. # Required. 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".

4269

"timestampValue": "A String", # timestamp

4270

"dayOfWeekValue": "A String", # day of week

4271

"stringValue": "A String", # string

4272

"booleanValue": True or False, # boolean

4273

"floatValue": 3.14, # float

4274

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4275

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4276

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4277

"day": 42, # 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.

4278

},

4279

"integerValue": "A String", # integer

4280

"timeValue": { # 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`. # time of day

4281

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4282

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4283

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4284

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4285

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4286

},

4287

"bucketSize": 3.14, # 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.

4288

},

4289

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

4290

"partToExtract": "A String", # The part of the time to keep.

4291

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4292

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

4293

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

4294

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4295

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4296

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4297

},

4298

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4299

"key": "A String", # Required. A 128/192/256 bit key.

4300

},

4301

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4302

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4303

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4304

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4305

},

4306

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4307

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

4308

"name": "A String", # Name describing the field.

4309

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4310

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

4311

"name": "A 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/dlp/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}`.

4312

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4313

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

4314

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4315

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4316

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4317

},

4318

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4319

"key": "A String", # Required. A 128/192/256 bit key.

4320

},

4321

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4322

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4323

},

4324

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

4325

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4326

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4327

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

4328

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4329

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4330

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4331

},

4332

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4333

"key": "A String", # Required. A 128/192/256 bit key.

4334

},

4335

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4336

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4337

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4338

},

4339

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4340

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

4341

"name": "A 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/dlp/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}`.

4342

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4343

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

4344

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

4345

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

4346

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4347

},

4348

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4349

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4350

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

4351

"name": "A String", # Name describing the field.

4352

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4353

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4354

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

4355

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4356

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4357

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4358

},

4359

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4360

"key": "A String", # Required. A 128/192/256 bit key.

4361

},

4362

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4363

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4364

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4365

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4366

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

4367

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

4368

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4369

"infoTypes": [ # 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`.

4370

{ # Type of information detected by the API.

4371

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4377

"recordTransformations": { # A type of transformation that is applied over structured data such as a table. # Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.

4378

"fieldTransformations": [ # Transform the record by applying various field transformations.

4379

{ # The transformation to apply to the field.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4380

"primitiveTransformation": { # A rule for transforming a value. # Apply the transformation to the entire field.

4381

"redactConfig": { # 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 '. # Redact

4382

},

4383

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

4384

"newValue": { # 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. # Value to replace it with.

4385

"timestampValue": "A String", # timestamp

4386

"dayOfWeekValue": "A String", # day of week

4387

"stringValue": "A String", # string

4388

"booleanValue": True or False, # boolean

4389

"floatValue": 3.14, # float

4390

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4391

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4392

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4393

"day": 42, # 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.

4394

},

4395

"integerValue": "A String", # integer

4396

"timeValue": { # 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`. # time of day

4397

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4398

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4399

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4400

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

"characterMaskConfig": { # 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. # Mask

4405

"maskingCharacter": "A 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.

4406

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

4407

"reverseOrder": True or False, # 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***`.

4408

"charactersToIgnore": [ # 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`.

4409

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

4410

"charactersToSkip": "A String", # Characters to not transform when masking.

4411

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

4416

},

4417

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

4418

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

4419

{ # Bucket is represented as a range, along with replacement values.

4420

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

4421

"timestampValue": "A String", # timestamp

4422

"dayOfWeekValue": "A String", # day of week

4423

"stringValue": "A String", # string

4424

"booleanValue": True or False, # boolean

4425

"floatValue": 3.14, # float

4426

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4427

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4428

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4429

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4430

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4431

"integerValue": "A String", # integer

4432

"timeValue": { # 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`. # time of day

4433

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4434

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4435

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4436

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4437

},

4438

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4439

"replacementValue": { # 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. # Required. Replacement value for this bucket.

4440

"timestampValue": "A String", # timestamp

4441

"dayOfWeekValue": "A String", # day of week

4442

"stringValue": "A String", # string

4443

"booleanValue": True or False, # boolean

4444

"floatValue": 3.14, # float

4445

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4446

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4447

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4448

"day": 42, # 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.

4449

},

4450

"integerValue": "A String", # integer

4451

"timeValue": { # 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`. # time of day

4452

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4453

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4454

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4455

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4456

},

4457

},

4458

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

4459

"timestampValue": "A String", # timestamp

4460

"dayOfWeekValue": "A String", # day of week

4461

"stringValue": "A String", # string

4462

"booleanValue": True or False, # boolean

4463

"floatValue": 3.14, # float

4464

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4465

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4466

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4467

"day": 42, # 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.

4468

},

4469

"integerValue": "A String", # integer

4470

"timeValue": { # 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`. # time of day

4471

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4472

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4473

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4474

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4479

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4480

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4481

"upperBound": { # 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. # Required. 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+".

4482

"timestampValue": "A String", # timestamp

4483

"dayOfWeekValue": "A String", # day of week

4484

"stringValue": "A String", # string

4485

"booleanValue": True or False, # boolean

4486

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4487

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4488

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4489

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4490

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4491

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4492

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4493

"timeValue": { # 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`. # time of day

4494

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4495

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4496

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4497

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4498

},

4499

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4500

"lowerBound": { # 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. # Required. 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".

4501

"timestampValue": "A String", # timestamp

4502

"dayOfWeekValue": "A String", # day of week

4503

"stringValue": "A String", # string

4504

"booleanValue": True or False, # boolean

4505

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4506

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4507

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4508

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4509

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4510

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4511

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4512

"timeValue": { # 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`. # time of day

4513

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4514

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4515

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4516

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4517

},

4518

},

4519

"bucketSize": 3.14, # 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.

4520

},

4521

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

4522

"partToExtract": "A String", # The part of the time to keep.

4523

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4524

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

4525

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

4526

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4527

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4528

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4529

},

4530

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4531

"key": "A String", # Required. A 128/192/256 bit key.

4532

},

4533

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4534

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4535

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4536

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4537

},

4538

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4539

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

4540

"name": "A String", # Name describing the field.

4541

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4542

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

4543

"name": "A 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/dlp/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}`.

4544

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4545

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

4546

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4547

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4548

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4549

},

4550

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4551

"key": "A String", # Required. A 128/192/256 bit key.

4552

},

4553

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4554

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

},

},

},

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4559

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

4560

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4561

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4562

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4563

},

4564

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4565

"key": "A String", # Required. A 128/192/256 bit key.

4566

},

4567

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4568

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4569

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4570

},

4571

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4572

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

4573

"name": "A 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/dlp/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}`.

4574

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4575

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

4576

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

4577

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

4578

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4579

},

4580

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4581

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4582

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

4583

"name": "A String", # Name describing the field.

4584

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4585

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4586

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

4587

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4588

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4589

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4590

},

4591

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4592

"key": "A String", # Required. A 128/192/256 bit key.

4593

},

4594

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4595

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4596

},

4597

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4598

"upperBoundDays": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4599

},

4600

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

4601

"infoTypeTransformations": { # 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. # Treat the contents of the field as free text, and selectively transform content that matches an `InfoType`.

4602

"transformations": [ # Required. Transformation for each infoType. Cannot specify more than one for a given infoType.

4603

{ # A transformation to apply to text that is identified as a specific info_type.

4604

"primitiveTransformation": { # A rule for transforming a value. # Required. Primitive transformation to apply to the infoType.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4605

"redactConfig": { # 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 '. # Redact

4606

},

4607

"replaceConfig": { # Replace each input value with a given `Value`. # Replace

4608

"newValue": { # 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. # Value to replace it with.

4609

"timestampValue": "A String", # timestamp

4610

"dayOfWeekValue": "A String", # day of week

4611

"stringValue": "A String", # string

4612

"booleanValue": True or False, # boolean

4613

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4614

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4615

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4616

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4617

"day": 42, # 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.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4618

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4619

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4620

"timeValue": { # 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`. # time of day

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4621

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4622

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4623

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4624

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4625

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4626

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4627

},

4628

"characterMaskConfig": { # 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. # Mask

4629

"maskingCharacter": "A 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.

4630

"numberToMask": 42, # Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.

4631

"reverseOrder": True or False, # 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***`.

4632

"charactersToIgnore": [ # 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`.

4633

{ # Characters to skip when doing deidentification of a value. These will be left alone and skipped.

4634

"charactersToSkip": "A String", # Characters to not transform when masking.

4635

"commonCharactersToIgnore": "A String", # Common characters to not transform when masking. Useful to avoid removing punctuation.

},

],

},

"replaceWithInfoTypeConfig": { # Replace each matching finding with the name of the info_type. # Replace with infotype

4640

},

4641

"bucketingConfig": { # 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/dlp/docs/concepts-bucketing to learn more. # Bucketing

4642

"buckets": [ # Set of buckets. Ranges must be non-overlapping.

4643

{ # Bucket is represented as a range, along with replacement values.

4644

"max": { # 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. # Upper bound of the range, exclusive; type must match min.

4645

"timestampValue": "A String", # timestamp

4646

"dayOfWeekValue": "A String", # day of week

4647

"stringValue": "A String", # string

4648

"booleanValue": True or False, # boolean

4649

"floatValue": 3.14, # float

4650

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4651

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4652

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4653

"day": 42, # 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.

4654

},

4655

"integerValue": "A String", # integer

4656

"timeValue": { # 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`. # time of day

4657

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4658

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4659

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4660

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4661

},

4662

},

4663

"replacementValue": { # 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. # Required. Replacement value for this bucket.

4664

"timestampValue": "A String", # timestamp

4665

"dayOfWeekValue": "A String", # day of week

4666

"stringValue": "A String", # string

4667

"booleanValue": True or False, # boolean

4668

"floatValue": 3.14, # float

4669

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4670

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4671

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4672

"day": 42, # 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.

4673

},

4674

"integerValue": "A String", # integer

4675

"timeValue": { # 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`. # time of day

4676

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4677

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4678

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4679

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4680

},

4681

},

4682

"min": { # 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. # Lower bound of the range, inclusive. Type should be the same as max if used.

4683

"timestampValue": "A String", # timestamp

4684

"dayOfWeekValue": "A String", # day of week

4685

"stringValue": "A String", # string

4686

"booleanValue": True or False, # boolean

4687

"floatValue": 3.14, # float

4688

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4689

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4690

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4691

"day": 42, # 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.

4692

},

4693

"integerValue": "A String", # integer

4694

"timeValue": { # 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`. # time of day

4695

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4696

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4697

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4698

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

},

},

},

],

},

"fixedSizeBucketingConfig": { # 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}, i.e 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/dlp/docs/concepts-bucketing to learn more. # Fixed size bucketing

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4705

"upperBound": { # 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. # Required. 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+".

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4706

"timestampValue": "A String", # timestamp

4707

"dayOfWeekValue": "A String", # day of week

4708

"stringValue": "A String", # string

4709

"booleanValue": True or False, # boolean

4710

"floatValue": 3.14, # float

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4711

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4712

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4713

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4714

"day": 42, # 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.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4715

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4716

"integerValue": "A String", # integer

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4717

"timeValue": { # 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`. # time of day

4718

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4719

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4720

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4721

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4722

},

4723

},

4724

"lowerBound": { # 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. # Required. 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".

4725

"timestampValue": "A String", # timestamp

4726

"dayOfWeekValue": "A String", # day of week

4727

"stringValue": "A String", # string

4728

"booleanValue": True or False, # boolean

4729

"floatValue": 3.14, # float

4730

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4731

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4732

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4733

"day": 42, # 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.

4734

},

4735

"integerValue": "A String", # integer

4736

"timeValue": { # 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`. # time of day

4737

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4738

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4739

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4740

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4741

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4742

},

4743

"bucketSize": 3.14, # 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.

4744

},

4745

"timePartConfig": { # For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a portion of the value. # Time extraction

4746

"partToExtract": "A String", # The part of the time to keep.

4747

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4748

"cryptoHashConfig": { # 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/dlp/docs/pseudonymization to learn more. # Crypto

4749

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the hash function.

4750

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4751

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4752

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4753

},

4754

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4755

"key": "A String", # Required. A 128/192/256 bit key.

4756

},

4757

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4758

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4759

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4760

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4761

},

4762

"cryptoDeterministicConfig": { # 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. # Deterministic Crypto

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4763

"context": { # General identifier of a data field in a storage service. # A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well. If the context is not set, plaintext would be used as is for encryption. If the context is set but: 1. there is no record present when transforming a given value or 2. the field is not present when transforming a given value, plaintext would be used as is for encryption. Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s.

4764

"name": "A String", # Name describing the field.

4765

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4766

"surrogateInfoType": { # Type of information detected by the API. # The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate} For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text. Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text. In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either - reverse a surrogate that does not correspond to an actual identifier - be unable to parse the surrogate and result in an error Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE.

4767

"name": "A 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/dlp/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}`.

4768

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4769

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # The key used by the encryption function.

4770

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4771

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4772

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4773

},

4774

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4775

"key": "A String", # Required. A 128/192/256 bit key.

4776

},

4777

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4778

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4779

},

4780

},

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

4781

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4782

"cryptoReplaceFfxFpeConfig": { # 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/dlp/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. # Ffx-Fpe

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4783

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Required. The key used by the encryption algorithm.

4784

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

4785

"wrappedKey": "A String", # Required. The wrapped data crypto key.

4786

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

4787

},

4788

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4789

"key": "A String", # Required. A 128/192/256 bit key.

4790

},

4791

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4792

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4793

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4794

},

4795

"commonAlphabet": "A String", # Common alphabets.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4796

"surrogateInfoType": { # Type of information detected by the API. # The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info_type_name(surrogate_character_count):surrogate For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY_TOKEN_INFO_TYPE(3):abc' This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text. In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY_TOKEN_TYPE

4797

"name": "A 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/dlp/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}`.

4798

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4799

"radix": 42, # The native way to select the alphabet. Must be in the range [2, 95].

4800

"customAlphabet": "A 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 ~`!@#$%^&*()_-+={[}]|\:;"'<,>.?/

4801

"context": { # General identifier of a data field in a storage service. # The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. 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

4802

"name": "A String", # Name describing the field.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4803

},

4804

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4805

"dateShiftConfig": { # Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more. # Date Shift

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4806

"context": { # General identifier of a data field in a storage service. # Points to the field that contains the context, for example, an entity id. If set, must also set cryptoKey. If set, shift will be consistent for the given context.

4807

"name": "A String", # Name describing the field.

4808

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4809

"lowerBoundDays": 42, # Required. For example, -5 means shift date to at most 5 days back in the past.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4810

"cryptoKey": { # This is a data encryption key (DEK) (as opposed to a key encryption key (KEK) stored by KMS). When using KMS to wrap/unwrap DEKs, be sure to set an appropriate IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot unwrap the data crypto key. # Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and crypto_key. If set, must also set context. Can only be applied to table items.

4811

"kmsWrapped": { # Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128/192/256 bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a kms-wrapped crypto key: dlp.kms.encrypt # Kms wrapped key

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4812

"wrappedKey": "A String", # Required. The wrapped data crypto key.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4813

"cryptoKeyName": "A String", # Required. The resource name of the KMS CryptoKey to use for unwrapping.

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4814

},

4815

"unwrapped": { # Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible. # Unwrapped crypto key

4816

"key": "A String", # Required. A 128/192/256 bit key.

4817

},

4818

"transient": { # Use this to have a random data crypto key generated. It will be discarded after the request finishes. # Transient crypto key

4819

"name": "A String", # Required. Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).

4820

},

Yoshi Automation Bot

2020-11-24 15:48:03 -0800

[diff] [blame]

4821

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4822

"upperBoundDays": 42, # 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.

Bu Sun Kim

2020-11-16 11:05:03 -0700

[diff] [blame]

4823

},

Dmitry Frenkel

2020-10-06 16:46:05 -0700

[diff] [blame]

4824

},

4825

"infoTypes": [ # 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`.

4826

{ # Type of information detected by the API.

4827

"name": "A 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/dlp/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}`.

},

],

},

],

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4833

"condition": { # A condition for determining whether a transformation should be applied to a field. # 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. 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.

4834

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

4835

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

4836

"conditions": [ # A collection of conditions.

4837

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

4838

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

4839

"timestampValue": "A String", # timestamp

4840

"dayOfWeekValue": "A String", # day of week

4841

"stringValue": "A String", # string

4842

"booleanValue": True or False, # boolean

4843

"floatValue": 3.14, # float

4844

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4845

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4846

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4847

"day": 42, # 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.

4848

},

4849

"integerValue": "A String", # integer

4850

"timeValue": { # 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`. # time of day

4851

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4852

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4853

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4854

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4855

},

4856

},

4857

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

4858

"name": "A String", # Name describing the field.

4859

},

4860

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

},

],

},

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

4865

},

4866

},

4867

"fields": [ # Required. Input field(s) to apply the transformation to.

4868

{ # General identifier of a data field in a storage service.

4869

"name": "A String", # Name describing the field.

4870

},

4871

],

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4872

},

4873

],

4874

"recordSuppressions": [ # Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.

4875

{ # Configuration to suppress records whose suppression conditions evaluate to true.

4876

"condition": { # A condition for determining whether a transformation should be applied to a field. # A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.

4877

"expressions": { # An expression, consisting or an operator and conditions. # An expression.

4878

"conditions": { # A collection of conditions. # Conditions to apply to the expression.

4879

"conditions": [ # A collection of conditions.

4880

{ # The field type of `value` and `field` do not need to match to be considered equal, but not all comparisons are possible. EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types, but all other comparisons are invalid with incompatible types. A `value` of type: - `string` can be compared against all other types - `boolean` can only be compared against other booleans - `integer` can be compared against doubles or a string if the string value can be parsed as an integer. - `double` can be compared against integers or a string if the string can be parsed as a double. - `Timestamp` can be compared against strings in RFC 3339 date string format. - `TimeOfDay` can be compared against timestamps and strings in the format of 'HH:mm:ss'. If we fail to compare do to type mismatch, a warning will be given and the condition will evaluate to false.

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4881

"value": { # 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. # Value to compare against. [Mandatory, except for `EXISTS` tests.]

4882

"timestampValue": "A String", # timestamp

4883

"dayOfWeekValue": "A String", # day of week

4884

"stringValue": "A String", # string

4885

"booleanValue": True or False, # boolean

4886

"floatValue": 3.14, # float

4887

"dateValue": { # 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 value, with a zero year, such as an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, such as a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # date

4888

"month": 42, # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.

4889

"year": 42, # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.

4890

"day": 42, # 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.

4891

},

4892

"integerValue": "A String", # integer

4893

"timeValue": { # 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`. # time of day

4894

"hours": 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.

4895

"nanos": 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.

4896

"minutes": 42, # Minutes of hour of day. Must be from 0 to 59.

4897

"seconds": 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

4898

},

4899

},

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4900

"field": { # General identifier of a data field in a storage service. # Required. Field within the record this condition is evaluated against.

4901

"name": "A String", # Name describing the field.

4902

},

Yoshi Automation Bot

2020-11-26 17:16:03 -0800

[diff] [blame]

4903

"operator": "A String", # Required. Operator used to compare the field or infoType to the value.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

4904

},

4905

],

4906

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4907

"logicalOperator": "A String", # The operator to apply to the result of conditions. Default and currently only supported value is `AND`.

Yoshi Automation Bot

2020-11-25 07:50:41 -0800

[diff] [blame]

},

},

},

],

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

4913

},

Yoshi Automation Bot

2020-12-09 08:56:03 -0800

[diff] [blame]

4914

"createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.

4915

"updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.

4916

"description": "A String", # Short description (max 256 chars).

4917

"displayName": "A String", # Display name (max 256 chars).

4918

"name": "A String", # Output only. The template name. The template will have one of the following formats: `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`

Bu Sun Kim