OLD | NEW |
| (Empty) |
1 // This is a generated file (see the discoveryapis_generator project). | |
2 | |
3 library googleapis_beta.cloudkms.v1beta1; | |
4 | |
5 import 'dart:core' as core; | |
6 import 'dart:async' as async; | |
7 import 'dart:convert' as convert; | |
8 | |
9 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons; | |
10 import 'package:http/http.dart' as http; | |
11 | |
12 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show | |
13 ApiRequestError, DetailedApiRequestError; | |
14 | |
15 const core.String USER_AGENT = 'dart-api-client cloudkms/v1beta1'; | |
16 | |
17 /** | |
18 * Manages encryption for your cloud services the same way you do on-premise. | |
19 * You can generate, use, rotate, and destroy AES256 encryption keys. | |
20 */ | |
21 class CloudkmsApi { | |
22 /** View and manage your data across Google Cloud Platform services */ | |
23 static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platf
orm"; | |
24 | |
25 | |
26 final commons.ApiRequester _requester; | |
27 | |
28 ProjectsResourceApi get projects => new ProjectsResourceApi(_requester); | |
29 | |
30 CloudkmsApi(http.Client client, {core.String rootUrl: "https://cloudkms.google
apis.com/", core.String servicePath: ""}) : | |
31 _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_A
GENT); | |
32 } | |
33 | |
34 | |
35 class ProjectsResourceApi { | |
36 final commons.ApiRequester _requester; | |
37 | |
38 ProjectsLocationsResourceApi get locations => new ProjectsLocationsResourceApi
(_requester); | |
39 | |
40 ProjectsResourceApi(commons.ApiRequester client) : | |
41 _requester = client; | |
42 } | |
43 | |
44 | |
45 class ProjectsLocationsResourceApi { | |
46 final commons.ApiRequester _requester; | |
47 | |
48 ProjectsLocationsKeyRingsResourceApi get keyRings => new ProjectsLocationsKeyR
ingsResourceApi(_requester); | |
49 | |
50 ProjectsLocationsResourceApi(commons.ApiRequester client) : | |
51 _requester = client; | |
52 | |
53 /** | |
54 * Get information about a location. | |
55 * | |
56 * Request parameters: | |
57 * | |
58 * [name] - Resource name for the location. | |
59 * Value must have pattern "^projects/[^/]+/locations/[^/]+$". | |
60 * | |
61 * Completes with a [Location]. | |
62 * | |
63 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
64 * error. | |
65 * | |
66 * If the used [http.Client] completes with an error when making a REST call, | |
67 * this method will complete with the same error. | |
68 */ | |
69 async.Future<Location> get(core.String name) { | |
70 var _url = null; | |
71 var _queryParams = new core.Map(); | |
72 var _uploadMedia = null; | |
73 var _uploadOptions = null; | |
74 var _downloadOptions = commons.DownloadOptions.Metadata; | |
75 var _body = null; | |
76 | |
77 if (name == null) { | |
78 throw new core.ArgumentError("Parameter name is required."); | |
79 } | |
80 | |
81 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
82 | |
83 var _response = _requester.request(_url, | |
84 "GET", | |
85 body: _body, | |
86 queryParams: _queryParams, | |
87 uploadOptions: _uploadOptions, | |
88 uploadMedia: _uploadMedia, | |
89 downloadOptions: _downloadOptions); | |
90 return _response.then((data) => new Location.fromJson(data)); | |
91 } | |
92 | |
93 /** | |
94 * Lists information about the supported locations for this service. | |
95 * | |
96 * Request parameters: | |
97 * | |
98 * [name] - The resource that owns the locations collection, if applicable. | |
99 * Value must have pattern "^projects/[^/]+$". | |
100 * | |
101 * [pageToken] - The standard list page token. | |
102 * | |
103 * [pageSize] - The standard list page size. | |
104 * | |
105 * [filter] - The standard list filter. | |
106 * | |
107 * Completes with a [ListLocationsResponse]. | |
108 * | |
109 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
110 * error. | |
111 * | |
112 * If the used [http.Client] completes with an error when making a REST call, | |
113 * this method will complete with the same error. | |
114 */ | |
115 async.Future<ListLocationsResponse> list(core.String name, {core.String pageTo
ken, core.int pageSize, core.String filter}) { | |
116 var _url = null; | |
117 var _queryParams = new core.Map(); | |
118 var _uploadMedia = null; | |
119 var _uploadOptions = null; | |
120 var _downloadOptions = commons.DownloadOptions.Metadata; | |
121 var _body = null; | |
122 | |
123 if (name == null) { | |
124 throw new core.ArgumentError("Parameter name is required."); | |
125 } | |
126 if (pageToken != null) { | |
127 _queryParams["pageToken"] = [pageToken]; | |
128 } | |
129 if (pageSize != null) { | |
130 _queryParams["pageSize"] = ["${pageSize}"]; | |
131 } | |
132 if (filter != null) { | |
133 _queryParams["filter"] = [filter]; | |
134 } | |
135 | |
136 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + '/locat
ions'; | |
137 | |
138 var _response = _requester.request(_url, | |
139 "GET", | |
140 body: _body, | |
141 queryParams: _queryParams, | |
142 uploadOptions: _uploadOptions, | |
143 uploadMedia: _uploadMedia, | |
144 downloadOptions: _downloadOptions); | |
145 return _response.then((data) => new ListLocationsResponse.fromJson(data)); | |
146 } | |
147 | |
148 } | |
149 | |
150 | |
151 class ProjectsLocationsKeyRingsResourceApi { | |
152 final commons.ApiRequester _requester; | |
153 | |
154 ProjectsLocationsKeyRingsCryptoKeysResourceApi get cryptoKeys => new ProjectsL
ocationsKeyRingsCryptoKeysResourceApi(_requester); | |
155 | |
156 ProjectsLocationsKeyRingsResourceApi(commons.ApiRequester client) : | |
157 _requester = client; | |
158 | |
159 /** | |
160 * Create a new KeyRing in a given Project and Location. | |
161 * | |
162 * [request] - The metadata request object. | |
163 * | |
164 * Request parameters: | |
165 * | |
166 * [parent] - Required. The resource name of the location associated with the | |
167 * KeyRings, in the format `projects / * /locations / * `. | |
168 * Value must have pattern "^projects/[^/]+/locations/[^/]+$". | |
169 * | |
170 * [keyRingId] - Required. It must be unique within a location and match the | |
171 * regular | |
172 * expression `[a-zA-Z0-9_-]{1,63}` | |
173 * | |
174 * Completes with a [KeyRing]. | |
175 * | |
176 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
177 * error. | |
178 * | |
179 * If the used [http.Client] completes with an error when making a REST call, | |
180 * this method will complete with the same error. | |
181 */ | |
182 async.Future<KeyRing> create(KeyRing request, core.String parent, {core.String
keyRingId}) { | |
183 var _url = null; | |
184 var _queryParams = new core.Map(); | |
185 var _uploadMedia = null; | |
186 var _uploadOptions = null; | |
187 var _downloadOptions = commons.DownloadOptions.Metadata; | |
188 var _body = null; | |
189 | |
190 if (request != null) { | |
191 _body = convert.JSON.encode((request).toJson()); | |
192 } | |
193 if (parent == null) { | |
194 throw new core.ArgumentError("Parameter parent is required."); | |
195 } | |
196 if (keyRingId != null) { | |
197 _queryParams["keyRingId"] = [keyRingId]; | |
198 } | |
199 | |
200 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/key
Rings'; | |
201 | |
202 var _response = _requester.request(_url, | |
203 "POST", | |
204 body: _body, | |
205 queryParams: _queryParams, | |
206 uploadOptions: _uploadOptions, | |
207 uploadMedia: _uploadMedia, | |
208 downloadOptions: _downloadOptions); | |
209 return _response.then((data) => new KeyRing.fromJson(data)); | |
210 } | |
211 | |
212 /** | |
213 * Returns metadata for a given KeyRing. | |
214 * | |
215 * Request parameters: | |
216 * | |
217 * [name] - The name of the KeyRing to get. | |
218 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
219 * | |
220 * Completes with a [KeyRing]. | |
221 * | |
222 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
223 * error. | |
224 * | |
225 * If the used [http.Client] completes with an error when making a REST call, | |
226 * this method will complete with the same error. | |
227 */ | |
228 async.Future<KeyRing> get(core.String name) { | |
229 var _url = null; | |
230 var _queryParams = new core.Map(); | |
231 var _uploadMedia = null; | |
232 var _uploadOptions = null; | |
233 var _downloadOptions = commons.DownloadOptions.Metadata; | |
234 var _body = null; | |
235 | |
236 if (name == null) { | |
237 throw new core.ArgumentError("Parameter name is required."); | |
238 } | |
239 | |
240 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
241 | |
242 var _response = _requester.request(_url, | |
243 "GET", | |
244 body: _body, | |
245 queryParams: _queryParams, | |
246 uploadOptions: _uploadOptions, | |
247 uploadMedia: _uploadMedia, | |
248 downloadOptions: _downloadOptions); | |
249 return _response.then((data) => new KeyRing.fromJson(data)); | |
250 } | |
251 | |
252 /** | |
253 * Gets the access control policy for a resource. | |
254 * Returns an empty policy if the resource exists and does not have a policy | |
255 * set. | |
256 * | |
257 * Request parameters: | |
258 * | |
259 * [resource] - REQUIRED: The resource for which the policy is being | |
260 * requested. | |
261 * `resource` is usually specified as a path. For example, a Project | |
262 * resource is specified as `projects/{project}`. | |
263 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
264 * | |
265 * Completes with a [Policy]. | |
266 * | |
267 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
268 * error. | |
269 * | |
270 * If the used [http.Client] completes with an error when making a REST call, | |
271 * this method will complete with the same error. | |
272 */ | |
273 async.Future<Policy> getIamPolicy(core.String resource) { | |
274 var _url = null; | |
275 var _queryParams = new core.Map(); | |
276 var _uploadMedia = null; | |
277 var _uploadOptions = null; | |
278 var _downloadOptions = commons.DownloadOptions.Metadata; | |
279 var _body = null; | |
280 | |
281 if (resource == null) { | |
282 throw new core.ArgumentError("Parameter resource is required."); | |
283 } | |
284 | |
285 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':g
etIamPolicy'; | |
286 | |
287 var _response = _requester.request(_url, | |
288 "GET", | |
289 body: _body, | |
290 queryParams: _queryParams, | |
291 uploadOptions: _uploadOptions, | |
292 uploadMedia: _uploadMedia, | |
293 downloadOptions: _downloadOptions); | |
294 return _response.then((data) => new Policy.fromJson(data)); | |
295 } | |
296 | |
297 /** | |
298 * Lists KeyRings. | |
299 * | |
300 * Request parameters: | |
301 * | |
302 * [parent] - Required. The resource name of the location associated with the | |
303 * KeyRings, in the format `projects / * /locations / * `. | |
304 * Value must have pattern "^projects/[^/]+/locations/[^/]+$". | |
305 * | |
306 * [pageToken] - Optional pagination token, returned earlier via | |
307 * ListKeyRingsResponse.next_page_token. | |
308 * | |
309 * [pageSize] - Optional limit on the number of KeyRings to include in the | |
310 * response. Further KeyRings can subsequently be obtained by | |
311 * including the ListKeyRingsResponse.next_page_token in a subsequent | |
312 * request. If unspecified, the server will pick an appropriate default. | |
313 * | |
314 * Completes with a [ListKeyRingsResponse]. | |
315 * | |
316 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
317 * error. | |
318 * | |
319 * If the used [http.Client] completes with an error when making a REST call, | |
320 * this method will complete with the same error. | |
321 */ | |
322 async.Future<ListKeyRingsResponse> list(core.String parent, {core.String pageT
oken, core.int pageSize}) { | |
323 var _url = null; | |
324 var _queryParams = new core.Map(); | |
325 var _uploadMedia = null; | |
326 var _uploadOptions = null; | |
327 var _downloadOptions = commons.DownloadOptions.Metadata; | |
328 var _body = null; | |
329 | |
330 if (parent == null) { | |
331 throw new core.ArgumentError("Parameter parent is required."); | |
332 } | |
333 if (pageToken != null) { | |
334 _queryParams["pageToken"] = [pageToken]; | |
335 } | |
336 if (pageSize != null) { | |
337 _queryParams["pageSize"] = ["${pageSize}"]; | |
338 } | |
339 | |
340 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/key
Rings'; | |
341 | |
342 var _response = _requester.request(_url, | |
343 "GET", | |
344 body: _body, | |
345 queryParams: _queryParams, | |
346 uploadOptions: _uploadOptions, | |
347 uploadMedia: _uploadMedia, | |
348 downloadOptions: _downloadOptions); | |
349 return _response.then((data) => new ListKeyRingsResponse.fromJson(data)); | |
350 } | |
351 | |
352 /** | |
353 * Sets the access control policy on the specified resource. Replaces any | |
354 * existing policy. | |
355 * | |
356 * [request] - The metadata request object. | |
357 * | |
358 * Request parameters: | |
359 * | |
360 * [resource] - REQUIRED: The resource for which the policy is being | |
361 * specified. | |
362 * `resource` is usually specified as a path. For example, a Project | |
363 * resource is specified as `projects/{project}`. | |
364 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
365 * | |
366 * Completes with a [Policy]. | |
367 * | |
368 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
369 * error. | |
370 * | |
371 * If the used [http.Client] completes with an error when making a REST call, | |
372 * this method will complete with the same error. | |
373 */ | |
374 async.Future<Policy> setIamPolicy(SetIamPolicyRequest request, core.String res
ource) { | |
375 var _url = null; | |
376 var _queryParams = new core.Map(); | |
377 var _uploadMedia = null; | |
378 var _uploadOptions = null; | |
379 var _downloadOptions = commons.DownloadOptions.Metadata; | |
380 var _body = null; | |
381 | |
382 if (request != null) { | |
383 _body = convert.JSON.encode((request).toJson()); | |
384 } | |
385 if (resource == null) { | |
386 throw new core.ArgumentError("Parameter resource is required."); | |
387 } | |
388 | |
389 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':s
etIamPolicy'; | |
390 | |
391 var _response = _requester.request(_url, | |
392 "POST", | |
393 body: _body, | |
394 queryParams: _queryParams, | |
395 uploadOptions: _uploadOptions, | |
396 uploadMedia: _uploadMedia, | |
397 downloadOptions: _downloadOptions); | |
398 return _response.then((data) => new Policy.fromJson(data)); | |
399 } | |
400 | |
401 /** | |
402 * Returns permissions that a caller has on the specified resource. | |
403 * If the resource does not exist, this will return an empty set of | |
404 * permissions, not a NOT_FOUND error. | |
405 * | |
406 * Note: This operation is designed to be used for building permission-aware | |
407 * UIs and command-line tools, not for authorization checking. This operation | |
408 * may "fail open" without warning. | |
409 * | |
410 * [request] - The metadata request object. | |
411 * | |
412 * Request parameters: | |
413 * | |
414 * [resource] - REQUIRED: The resource for which the policy detail is being | |
415 * requested. | |
416 * `resource` is usually specified as a path. For example, a Project | |
417 * resource is specified as `projects/{project}`. | |
418 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
419 * | |
420 * Completes with a [TestIamPermissionsResponse]. | |
421 * | |
422 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
423 * error. | |
424 * | |
425 * If the used [http.Client] completes with an error when making a REST call, | |
426 * this method will complete with the same error. | |
427 */ | |
428 async.Future<TestIamPermissionsResponse> testIamPermissions(TestIamPermissions
Request request, core.String resource) { | |
429 var _url = null; | |
430 var _queryParams = new core.Map(); | |
431 var _uploadMedia = null; | |
432 var _uploadOptions = null; | |
433 var _downloadOptions = commons.DownloadOptions.Metadata; | |
434 var _body = null; | |
435 | |
436 if (request != null) { | |
437 _body = convert.JSON.encode((request).toJson()); | |
438 } | |
439 if (resource == null) { | |
440 throw new core.ArgumentError("Parameter resource is required."); | |
441 } | |
442 | |
443 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':t
estIamPermissions'; | |
444 | |
445 var _response = _requester.request(_url, | |
446 "POST", | |
447 body: _body, | |
448 queryParams: _queryParams, | |
449 uploadOptions: _uploadOptions, | |
450 uploadMedia: _uploadMedia, | |
451 downloadOptions: _downloadOptions); | |
452 return _response.then((data) => new TestIamPermissionsResponse.fromJson(data
)); | |
453 } | |
454 | |
455 } | |
456 | |
457 | |
458 class ProjectsLocationsKeyRingsCryptoKeysResourceApi { | |
459 final commons.ApiRequester _requester; | |
460 | |
461 ProjectsLocationsKeyRingsCryptoKeysCryptoKeyVersionsResourceApi get cryptoKeyV
ersions => new ProjectsLocationsKeyRingsCryptoKeysCryptoKeyVersionsResourceApi(_
requester); | |
462 | |
463 ProjectsLocationsKeyRingsCryptoKeysResourceApi(commons.ApiRequester client) : | |
464 _requester = client; | |
465 | |
466 /** | |
467 * Create a new CryptoKey within a KeyRing. | |
468 * | |
469 * CryptoKey.purpose is required. | |
470 * | |
471 * [request] - The metadata request object. | |
472 * | |
473 * Request parameters: | |
474 * | |
475 * [parent] - Required. The name of the KeyRing associated with the | |
476 * CryptoKeys. | |
477 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
478 * | |
479 * [cryptoKeyId] - Required. It must be unique within a KeyRing and match the | |
480 * regular | |
481 * expression `[a-zA-Z0-9_-]{1,63}` | |
482 * | |
483 * Completes with a [CryptoKey]. | |
484 * | |
485 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
486 * error. | |
487 * | |
488 * If the used [http.Client] completes with an error when making a REST call, | |
489 * this method will complete with the same error. | |
490 */ | |
491 async.Future<CryptoKey> create(CryptoKey request, core.String parent, {core.St
ring cryptoKeyId}) { | |
492 var _url = null; | |
493 var _queryParams = new core.Map(); | |
494 var _uploadMedia = null; | |
495 var _uploadOptions = null; | |
496 var _downloadOptions = commons.DownloadOptions.Metadata; | |
497 var _body = null; | |
498 | |
499 if (request != null) { | |
500 _body = convert.JSON.encode((request).toJson()); | |
501 } | |
502 if (parent == null) { | |
503 throw new core.ArgumentError("Parameter parent is required."); | |
504 } | |
505 if (cryptoKeyId != null) { | |
506 _queryParams["cryptoKeyId"] = [cryptoKeyId]; | |
507 } | |
508 | |
509 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/cry
ptoKeys'; | |
510 | |
511 var _response = _requester.request(_url, | |
512 "POST", | |
513 body: _body, | |
514 queryParams: _queryParams, | |
515 uploadOptions: _uploadOptions, | |
516 uploadMedia: _uploadMedia, | |
517 downloadOptions: _downloadOptions); | |
518 return _response.then((data) => new CryptoKey.fromJson(data)); | |
519 } | |
520 | |
521 /** | |
522 * Decrypt data that was protected by Encrypt. | |
523 * | |
524 * [request] - The metadata request object. | |
525 * | |
526 * Request parameters: | |
527 * | |
528 * [name] - Required. The resource name of the CryptoKey to use for | |
529 * decryption. | |
530 * The server will choose the appropriate version. | |
531 * Value must have pattern | |
532 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
533 * | |
534 * Completes with a [DecryptResponse]. | |
535 * | |
536 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
537 * error. | |
538 * | |
539 * If the used [http.Client] completes with an error when making a REST call, | |
540 * this method will complete with the same error. | |
541 */ | |
542 async.Future<DecryptResponse> decrypt(DecryptRequest request, core.String name
) { | |
543 var _url = null; | |
544 var _queryParams = new core.Map(); | |
545 var _uploadMedia = null; | |
546 var _uploadOptions = null; | |
547 var _downloadOptions = commons.DownloadOptions.Metadata; | |
548 var _body = null; | |
549 | |
550 if (request != null) { | |
551 _body = convert.JSON.encode((request).toJson()); | |
552 } | |
553 if (name == null) { | |
554 throw new core.ArgumentError("Parameter name is required."); | |
555 } | |
556 | |
557 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':decry
pt'; | |
558 | |
559 var _response = _requester.request(_url, | |
560 "POST", | |
561 body: _body, | |
562 queryParams: _queryParams, | |
563 uploadOptions: _uploadOptions, | |
564 uploadMedia: _uploadMedia, | |
565 downloadOptions: _downloadOptions); | |
566 return _response.then((data) => new DecryptResponse.fromJson(data)); | |
567 } | |
568 | |
569 /** | |
570 * Encrypt data, so that it can only be recovered by a call to Decrypt. | |
571 * | |
572 * [request] - The metadata request object. | |
573 * | |
574 * Request parameters: | |
575 * | |
576 * [name] - Required. The resource name of the CryptoKey or CryptoKeyVersion | |
577 * to use for encryption. | |
578 * | |
579 * If a CryptoKey is specified, the server will use its | |
580 * primary version. | |
581 * Value must have pattern | |
582 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/.+$". | |
583 * | |
584 * Completes with a [EncryptResponse]. | |
585 * | |
586 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
587 * error. | |
588 * | |
589 * If the used [http.Client] completes with an error when making a REST call, | |
590 * this method will complete with the same error. | |
591 */ | |
592 async.Future<EncryptResponse> encrypt(EncryptRequest request, core.String name
) { | |
593 var _url = null; | |
594 var _queryParams = new core.Map(); | |
595 var _uploadMedia = null; | |
596 var _uploadOptions = null; | |
597 var _downloadOptions = commons.DownloadOptions.Metadata; | |
598 var _body = null; | |
599 | |
600 if (request != null) { | |
601 _body = convert.JSON.encode((request).toJson()); | |
602 } | |
603 if (name == null) { | |
604 throw new core.ArgumentError("Parameter name is required."); | |
605 } | |
606 | |
607 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':encry
pt'; | |
608 | |
609 var _response = _requester.request(_url, | |
610 "POST", | |
611 body: _body, | |
612 queryParams: _queryParams, | |
613 uploadOptions: _uploadOptions, | |
614 uploadMedia: _uploadMedia, | |
615 downloadOptions: _downloadOptions); | |
616 return _response.then((data) => new EncryptResponse.fromJson(data)); | |
617 } | |
618 | |
619 /** | |
620 * Returns metadata for a given CryptoKey, as well as its | |
621 * primary CryptoKeyVersion. | |
622 * | |
623 * Request parameters: | |
624 * | |
625 * [name] - The name of the CryptoKey to get. | |
626 * Value must have pattern | |
627 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
628 * | |
629 * Completes with a [CryptoKey]. | |
630 * | |
631 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
632 * error. | |
633 * | |
634 * If the used [http.Client] completes with an error when making a REST call, | |
635 * this method will complete with the same error. | |
636 */ | |
637 async.Future<CryptoKey> get(core.String name) { | |
638 var _url = null; | |
639 var _queryParams = new core.Map(); | |
640 var _uploadMedia = null; | |
641 var _uploadOptions = null; | |
642 var _downloadOptions = commons.DownloadOptions.Metadata; | |
643 var _body = null; | |
644 | |
645 if (name == null) { | |
646 throw new core.ArgumentError("Parameter name is required."); | |
647 } | |
648 | |
649 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
650 | |
651 var _response = _requester.request(_url, | |
652 "GET", | |
653 body: _body, | |
654 queryParams: _queryParams, | |
655 uploadOptions: _uploadOptions, | |
656 uploadMedia: _uploadMedia, | |
657 downloadOptions: _downloadOptions); | |
658 return _response.then((data) => new CryptoKey.fromJson(data)); | |
659 } | |
660 | |
661 /** | |
662 * Gets the access control policy for a resource. | |
663 * Returns an empty policy if the resource exists and does not have a policy | |
664 * set. | |
665 * | |
666 * Request parameters: | |
667 * | |
668 * [resource] - REQUIRED: The resource for which the policy is being | |
669 * requested. | |
670 * `resource` is usually specified as a path. For example, a Project | |
671 * resource is specified as `projects/{project}`. | |
672 * Value must have pattern | |
673 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
674 * | |
675 * Completes with a [Policy]. | |
676 * | |
677 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
678 * error. | |
679 * | |
680 * If the used [http.Client] completes with an error when making a REST call, | |
681 * this method will complete with the same error. | |
682 */ | |
683 async.Future<Policy> getIamPolicy(core.String resource) { | |
684 var _url = null; | |
685 var _queryParams = new core.Map(); | |
686 var _uploadMedia = null; | |
687 var _uploadOptions = null; | |
688 var _downloadOptions = commons.DownloadOptions.Metadata; | |
689 var _body = null; | |
690 | |
691 if (resource == null) { | |
692 throw new core.ArgumentError("Parameter resource is required."); | |
693 } | |
694 | |
695 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':g
etIamPolicy'; | |
696 | |
697 var _response = _requester.request(_url, | |
698 "GET", | |
699 body: _body, | |
700 queryParams: _queryParams, | |
701 uploadOptions: _uploadOptions, | |
702 uploadMedia: _uploadMedia, | |
703 downloadOptions: _downloadOptions); | |
704 return _response.then((data) => new Policy.fromJson(data)); | |
705 } | |
706 | |
707 /** | |
708 * Lists CryptoKeys. | |
709 * | |
710 * Request parameters: | |
711 * | |
712 * [parent] - Required. The resource name of the KeyRing to list, in the | |
713 * format | |
714 * `projects / * /locations / * /keyRings / * `. | |
715 * Value must have pattern "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+$". | |
716 * | |
717 * [pageToken] - Optional pagination token, returned earlier via | |
718 * ListCryptoKeysResponse.next_page_token. | |
719 * | |
720 * [pageSize] - Optional limit on the number of CryptoKeys to include in the | |
721 * response. Further CryptoKeys can subsequently be obtained by | |
722 * including the ListCryptoKeysResponse.next_page_token in a subsequent | |
723 * request. If unspecified, the server will pick an appropriate default. | |
724 * | |
725 * Completes with a [ListCryptoKeysResponse]. | |
726 * | |
727 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
728 * error. | |
729 * | |
730 * If the used [http.Client] completes with an error when making a REST call, | |
731 * this method will complete with the same error. | |
732 */ | |
733 async.Future<ListCryptoKeysResponse> list(core.String parent, {core.String pag
eToken, core.int pageSize}) { | |
734 var _url = null; | |
735 var _queryParams = new core.Map(); | |
736 var _uploadMedia = null; | |
737 var _uploadOptions = null; | |
738 var _downloadOptions = commons.DownloadOptions.Metadata; | |
739 var _body = null; | |
740 | |
741 if (parent == null) { | |
742 throw new core.ArgumentError("Parameter parent is required."); | |
743 } | |
744 if (pageToken != null) { | |
745 _queryParams["pageToken"] = [pageToken]; | |
746 } | |
747 if (pageSize != null) { | |
748 _queryParams["pageSize"] = ["${pageSize}"]; | |
749 } | |
750 | |
751 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/cry
ptoKeys'; | |
752 | |
753 var _response = _requester.request(_url, | |
754 "GET", | |
755 body: _body, | |
756 queryParams: _queryParams, | |
757 uploadOptions: _uploadOptions, | |
758 uploadMedia: _uploadMedia, | |
759 downloadOptions: _downloadOptions); | |
760 return _response.then((data) => new ListCryptoKeysResponse.fromJson(data)); | |
761 } | |
762 | |
763 /** | |
764 * Update a CryptoKey. | |
765 * | |
766 * [request] - The metadata request object. | |
767 * | |
768 * Request parameters: | |
769 * | |
770 * [name] - Output only. The resource name for this CryptoKey in the format | |
771 * `projects / * /locations / * /keyRings / * /cryptoKeys / * `. | |
772 * Value must have pattern | |
773 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
774 * | |
775 * [updateMask] - Required list of fields to be updated in this request. | |
776 * | |
777 * Completes with a [CryptoKey]. | |
778 * | |
779 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
780 * error. | |
781 * | |
782 * If the used [http.Client] completes with an error when making a REST call, | |
783 * this method will complete with the same error. | |
784 */ | |
785 async.Future<CryptoKey> patch(CryptoKey request, core.String name, {core.Strin
g updateMask}) { | |
786 var _url = null; | |
787 var _queryParams = new core.Map(); | |
788 var _uploadMedia = null; | |
789 var _uploadOptions = null; | |
790 var _downloadOptions = commons.DownloadOptions.Metadata; | |
791 var _body = null; | |
792 | |
793 if (request != null) { | |
794 _body = convert.JSON.encode((request).toJson()); | |
795 } | |
796 if (name == null) { | |
797 throw new core.ArgumentError("Parameter name is required."); | |
798 } | |
799 if (updateMask != null) { | |
800 _queryParams["updateMask"] = [updateMask]; | |
801 } | |
802 | |
803 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
804 | |
805 var _response = _requester.request(_url, | |
806 "PATCH", | |
807 body: _body, | |
808 queryParams: _queryParams, | |
809 uploadOptions: _uploadOptions, | |
810 uploadMedia: _uploadMedia, | |
811 downloadOptions: _downloadOptions); | |
812 return _response.then((data) => new CryptoKey.fromJson(data)); | |
813 } | |
814 | |
815 /** | |
816 * Sets the access control policy on the specified resource. Replaces any | |
817 * existing policy. | |
818 * | |
819 * [request] - The metadata request object. | |
820 * | |
821 * Request parameters: | |
822 * | |
823 * [resource] - REQUIRED: The resource for which the policy is being | |
824 * specified. | |
825 * `resource` is usually specified as a path. For example, a Project | |
826 * resource is specified as `projects/{project}`. | |
827 * Value must have pattern | |
828 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
829 * | |
830 * Completes with a [Policy]. | |
831 * | |
832 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
833 * error. | |
834 * | |
835 * If the used [http.Client] completes with an error when making a REST call, | |
836 * this method will complete with the same error. | |
837 */ | |
838 async.Future<Policy> setIamPolicy(SetIamPolicyRequest request, core.String res
ource) { | |
839 var _url = null; | |
840 var _queryParams = new core.Map(); | |
841 var _uploadMedia = null; | |
842 var _uploadOptions = null; | |
843 var _downloadOptions = commons.DownloadOptions.Metadata; | |
844 var _body = null; | |
845 | |
846 if (request != null) { | |
847 _body = convert.JSON.encode((request).toJson()); | |
848 } | |
849 if (resource == null) { | |
850 throw new core.ArgumentError("Parameter resource is required."); | |
851 } | |
852 | |
853 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':s
etIamPolicy'; | |
854 | |
855 var _response = _requester.request(_url, | |
856 "POST", | |
857 body: _body, | |
858 queryParams: _queryParams, | |
859 uploadOptions: _uploadOptions, | |
860 uploadMedia: _uploadMedia, | |
861 downloadOptions: _downloadOptions); | |
862 return _response.then((data) => new Policy.fromJson(data)); | |
863 } | |
864 | |
865 /** | |
866 * Returns permissions that a caller has on the specified resource. | |
867 * If the resource does not exist, this will return an empty set of | |
868 * permissions, not a NOT_FOUND error. | |
869 * | |
870 * Note: This operation is designed to be used for building permission-aware | |
871 * UIs and command-line tools, not for authorization checking. This operation | |
872 * may "fail open" without warning. | |
873 * | |
874 * [request] - The metadata request object. | |
875 * | |
876 * Request parameters: | |
877 * | |
878 * [resource] - REQUIRED: The resource for which the policy detail is being | |
879 * requested. | |
880 * `resource` is usually specified as a path. For example, a Project | |
881 * resource is specified as `projects/{project}`. | |
882 * Value must have pattern | |
883 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
884 * | |
885 * Completes with a [TestIamPermissionsResponse]. | |
886 * | |
887 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
888 * error. | |
889 * | |
890 * If the used [http.Client] completes with an error when making a REST call, | |
891 * this method will complete with the same error. | |
892 */ | |
893 async.Future<TestIamPermissionsResponse> testIamPermissions(TestIamPermissions
Request request, core.String resource) { | |
894 var _url = null; | |
895 var _queryParams = new core.Map(); | |
896 var _uploadMedia = null; | |
897 var _uploadOptions = null; | |
898 var _downloadOptions = commons.DownloadOptions.Metadata; | |
899 var _body = null; | |
900 | |
901 if (request != null) { | |
902 _body = convert.JSON.encode((request).toJson()); | |
903 } | |
904 if (resource == null) { | |
905 throw new core.ArgumentError("Parameter resource is required."); | |
906 } | |
907 | |
908 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$resource') + ':t
estIamPermissions'; | |
909 | |
910 var _response = _requester.request(_url, | |
911 "POST", | |
912 body: _body, | |
913 queryParams: _queryParams, | |
914 uploadOptions: _uploadOptions, | |
915 uploadMedia: _uploadMedia, | |
916 downloadOptions: _downloadOptions); | |
917 return _response.then((data) => new TestIamPermissionsResponse.fromJson(data
)); | |
918 } | |
919 | |
920 /** | |
921 * Update the version of a CryptoKey that will be used in Encrypt | |
922 * | |
923 * [request] - The metadata request object. | |
924 * | |
925 * Request parameters: | |
926 * | |
927 * [name] - The resource name of the CryptoKey to update. | |
928 * Value must have pattern | |
929 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
930 * | |
931 * Completes with a [CryptoKey]. | |
932 * | |
933 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
934 * error. | |
935 * | |
936 * If the used [http.Client] completes with an error when making a REST call, | |
937 * this method will complete with the same error. | |
938 */ | |
939 async.Future<CryptoKey> updatePrimaryVersion(UpdateCryptoKeyPrimaryVersionRequ
est request, core.String name) { | |
940 var _url = null; | |
941 var _queryParams = new core.Map(); | |
942 var _uploadMedia = null; | |
943 var _uploadOptions = null; | |
944 var _downloadOptions = commons.DownloadOptions.Metadata; | |
945 var _body = null; | |
946 | |
947 if (request != null) { | |
948 _body = convert.JSON.encode((request).toJson()); | |
949 } | |
950 if (name == null) { | |
951 throw new core.ArgumentError("Parameter name is required."); | |
952 } | |
953 | |
954 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':updat
ePrimaryVersion'; | |
955 | |
956 var _response = _requester.request(_url, | |
957 "POST", | |
958 body: _body, | |
959 queryParams: _queryParams, | |
960 uploadOptions: _uploadOptions, | |
961 uploadMedia: _uploadMedia, | |
962 downloadOptions: _downloadOptions); | |
963 return _response.then((data) => new CryptoKey.fromJson(data)); | |
964 } | |
965 | |
966 } | |
967 | |
968 | |
969 class ProjectsLocationsKeyRingsCryptoKeysCryptoKeyVersionsResourceApi { | |
970 final commons.ApiRequester _requester; | |
971 | |
972 ProjectsLocationsKeyRingsCryptoKeysCryptoKeyVersionsResourceApi(commons.ApiReq
uester client) : | |
973 _requester = client; | |
974 | |
975 /** | |
976 * Create a new CryptoKeyVersion in a CryptoKey. | |
977 * | |
978 * The server will assign the next sequential id. If unset, | |
979 * state will be set to | |
980 * ENABLED. | |
981 * | |
982 * [request] - The metadata request object. | |
983 * | |
984 * Request parameters: | |
985 * | |
986 * [parent] - Required. The name of the CryptoKey associated with | |
987 * the CryptoKeyVersions. | |
988 * Value must have pattern | |
989 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
990 * | |
991 * Completes with a [CryptoKeyVersion]. | |
992 * | |
993 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
994 * error. | |
995 * | |
996 * If the used [http.Client] completes with an error when making a REST call, | |
997 * this method will complete with the same error. | |
998 */ | |
999 async.Future<CryptoKeyVersion> create(CryptoKeyVersion request, core.String pa
rent) { | |
1000 var _url = null; | |
1001 var _queryParams = new core.Map(); | |
1002 var _uploadMedia = null; | |
1003 var _uploadOptions = null; | |
1004 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1005 var _body = null; | |
1006 | |
1007 if (request != null) { | |
1008 _body = convert.JSON.encode((request).toJson()); | |
1009 } | |
1010 if (parent == null) { | |
1011 throw new core.ArgumentError("Parameter parent is required."); | |
1012 } | |
1013 | |
1014 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/cry
ptoKeyVersions'; | |
1015 | |
1016 var _response = _requester.request(_url, | |
1017 "POST", | |
1018 body: _body, | |
1019 queryParams: _queryParams, | |
1020 uploadOptions: _uploadOptions, | |
1021 uploadMedia: _uploadMedia, | |
1022 downloadOptions: _downloadOptions); | |
1023 return _response.then((data) => new CryptoKeyVersion.fromJson(data)); | |
1024 } | |
1025 | |
1026 /** | |
1027 * Schedule a CryptoKeyVersion for destruction. | |
1028 * | |
1029 * Upon calling this method, CryptoKeyVersion.state will be set to | |
1030 * DESTROY_SCHEDULED | |
1031 * and destroy_time will be set to a time 24 | |
1032 * hours in the future, at which point the state | |
1033 * will be changed to | |
1034 * DESTROYED, and the key | |
1035 * material will be irrevocably destroyed. | |
1036 * | |
1037 * Before the destroy_time is reached, | |
1038 * RestoreCryptoKeyVersion may be called to reverse the process. | |
1039 * | |
1040 * [request] - The metadata request object. | |
1041 * | |
1042 * Request parameters: | |
1043 * | |
1044 * [name] - The resource name of the CryptoKeyVersion to destroy. | |
1045 * Value must have pattern | |
1046 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+/cryptoKeyV
ersions/[^/]+$". | |
1047 * | |
1048 * Completes with a [CryptoKeyVersion]. | |
1049 * | |
1050 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
1051 * error. | |
1052 * | |
1053 * If the used [http.Client] completes with an error when making a REST call, | |
1054 * this method will complete with the same error. | |
1055 */ | |
1056 async.Future<CryptoKeyVersion> destroy(DestroyCryptoKeyVersionRequest request,
core.String name) { | |
1057 var _url = null; | |
1058 var _queryParams = new core.Map(); | |
1059 var _uploadMedia = null; | |
1060 var _uploadOptions = null; | |
1061 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1062 var _body = null; | |
1063 | |
1064 if (request != null) { | |
1065 _body = convert.JSON.encode((request).toJson()); | |
1066 } | |
1067 if (name == null) { | |
1068 throw new core.ArgumentError("Parameter name is required."); | |
1069 } | |
1070 | |
1071 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':destr
oy'; | |
1072 | |
1073 var _response = _requester.request(_url, | |
1074 "POST", | |
1075 body: _body, | |
1076 queryParams: _queryParams, | |
1077 uploadOptions: _uploadOptions, | |
1078 uploadMedia: _uploadMedia, | |
1079 downloadOptions: _downloadOptions); | |
1080 return _response.then((data) => new CryptoKeyVersion.fromJson(data)); | |
1081 } | |
1082 | |
1083 /** | |
1084 * Returns metadata for a given CryptoKeyVersion. | |
1085 * | |
1086 * Request parameters: | |
1087 * | |
1088 * [name] - The name of the CryptoKeyVersion to get. | |
1089 * Value must have pattern | |
1090 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+/cryptoKeyV
ersions/[^/]+$". | |
1091 * | |
1092 * Completes with a [CryptoKeyVersion]. | |
1093 * | |
1094 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
1095 * error. | |
1096 * | |
1097 * If the used [http.Client] completes with an error when making a REST call, | |
1098 * this method will complete with the same error. | |
1099 */ | |
1100 async.Future<CryptoKeyVersion> get(core.String name) { | |
1101 var _url = null; | |
1102 var _queryParams = new core.Map(); | |
1103 var _uploadMedia = null; | |
1104 var _uploadOptions = null; | |
1105 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1106 var _body = null; | |
1107 | |
1108 if (name == null) { | |
1109 throw new core.ArgumentError("Parameter name is required."); | |
1110 } | |
1111 | |
1112 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
1113 | |
1114 var _response = _requester.request(_url, | |
1115 "GET", | |
1116 body: _body, | |
1117 queryParams: _queryParams, | |
1118 uploadOptions: _uploadOptions, | |
1119 uploadMedia: _uploadMedia, | |
1120 downloadOptions: _downloadOptions); | |
1121 return _response.then((data) => new CryptoKeyVersion.fromJson(data)); | |
1122 } | |
1123 | |
1124 /** | |
1125 * Lists CryptoKeyVersions. | |
1126 * | |
1127 * Request parameters: | |
1128 * | |
1129 * [parent] - Required. The resource name of the CryptoKey to list, in the | |
1130 * format | |
1131 * `projects / * /locations / * /keyRings / * /cryptoKeys / * `. | |
1132 * Value must have pattern | |
1133 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+$". | |
1134 * | |
1135 * [pageToken] - Optional pagination token, returned earlier via | |
1136 * ListCryptoKeyVersionsResponse.next_page_token. | |
1137 * | |
1138 * [pageSize] - Optional limit on the number of CryptoKeyVersions to | |
1139 * include in the response. Further CryptoKeyVersions can | |
1140 * subsequently be obtained by including the | |
1141 * ListCryptoKeyVersionsResponse.next_page_token in a subsequent request. | |
1142 * If unspecified, the server will pick an appropriate default. | |
1143 * | |
1144 * Completes with a [ListCryptoKeyVersionsResponse]. | |
1145 * | |
1146 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
1147 * error. | |
1148 * | |
1149 * If the used [http.Client] completes with an error when making a REST call, | |
1150 * this method will complete with the same error. | |
1151 */ | |
1152 async.Future<ListCryptoKeyVersionsResponse> list(core.String parent, {core.Str
ing pageToken, core.int pageSize}) { | |
1153 var _url = null; | |
1154 var _queryParams = new core.Map(); | |
1155 var _uploadMedia = null; | |
1156 var _uploadOptions = null; | |
1157 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1158 var _body = null; | |
1159 | |
1160 if (parent == null) { | |
1161 throw new core.ArgumentError("Parameter parent is required."); | |
1162 } | |
1163 if (pageToken != null) { | |
1164 _queryParams["pageToken"] = [pageToken]; | |
1165 } | |
1166 if (pageSize != null) { | |
1167 _queryParams["pageSize"] = ["${pageSize}"]; | |
1168 } | |
1169 | |
1170 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/cry
ptoKeyVersions'; | |
1171 | |
1172 var _response = _requester.request(_url, | |
1173 "GET", | |
1174 body: _body, | |
1175 queryParams: _queryParams, | |
1176 uploadOptions: _uploadOptions, | |
1177 uploadMedia: _uploadMedia, | |
1178 downloadOptions: _downloadOptions); | |
1179 return _response.then((data) => new ListCryptoKeyVersionsResponse.fromJson(d
ata)); | |
1180 } | |
1181 | |
1182 /** | |
1183 * Update a CryptoKeyVersion's metadata. | |
1184 * | |
1185 * state may be changed between | |
1186 * ENABLED and | |
1187 * DISABLED using this | |
1188 * method. See DestroyCryptoKeyVersion and RestoreCryptoKeyVersion to | |
1189 * move between other states. | |
1190 * | |
1191 * [request] - The metadata request object. | |
1192 * | |
1193 * Request parameters: | |
1194 * | |
1195 * [name] - Output only. The resource name for this CryptoKeyVersion in the | |
1196 * format | |
1197 * `projects / * /locations / * /keyRings / * /cryptoKeys / * | |
1198 * /cryptoKeyVersions / * `. | |
1199 * Value must have pattern | |
1200 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+/cryptoKeyV
ersions/[^/]+$". | |
1201 * | |
1202 * [updateMask] - Required list of fields to be updated in this request. | |
1203 * | |
1204 * Completes with a [CryptoKeyVersion]. | |
1205 * | |
1206 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
1207 * error. | |
1208 * | |
1209 * If the used [http.Client] completes with an error when making a REST call, | |
1210 * this method will complete with the same error. | |
1211 */ | |
1212 async.Future<CryptoKeyVersion> patch(CryptoKeyVersion request, core.String nam
e, {core.String updateMask}) { | |
1213 var _url = null; | |
1214 var _queryParams = new core.Map(); | |
1215 var _uploadMedia = null; | |
1216 var _uploadOptions = null; | |
1217 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1218 var _body = null; | |
1219 | |
1220 if (request != null) { | |
1221 _body = convert.JSON.encode((request).toJson()); | |
1222 } | |
1223 if (name == null) { | |
1224 throw new core.ArgumentError("Parameter name is required."); | |
1225 } | |
1226 if (updateMask != null) { | |
1227 _queryParams["updateMask"] = [updateMask]; | |
1228 } | |
1229 | |
1230 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name'); | |
1231 | |
1232 var _response = _requester.request(_url, | |
1233 "PATCH", | |
1234 body: _body, | |
1235 queryParams: _queryParams, | |
1236 uploadOptions: _uploadOptions, | |
1237 uploadMedia: _uploadMedia, | |
1238 downloadOptions: _downloadOptions); | |
1239 return _response.then((data) => new CryptoKeyVersion.fromJson(data)); | |
1240 } | |
1241 | |
1242 /** | |
1243 * Restore a CryptoKeyVersion in the | |
1244 * DESTROY_SCHEDULED, | |
1245 * state. | |
1246 * | |
1247 * Upon restoration of the CryptoKeyVersion, state | |
1248 * will be set to DISABLED, | |
1249 * and destroy_time will be cleared. | |
1250 * | |
1251 * [request] - The metadata request object. | |
1252 * | |
1253 * Request parameters: | |
1254 * | |
1255 * [name] - The resource name of the CryptoKeyVersion to restore. | |
1256 * Value must have pattern | |
1257 * "^projects/[^/]+/locations/[^/]+/keyRings/[^/]+/cryptoKeys/[^/]+/cryptoKeyV
ersions/[^/]+$". | |
1258 * | |
1259 * Completes with a [CryptoKeyVersion]. | |
1260 * | |
1261 * Completes with a [commons.ApiRequestError] if the API endpoint returned an | |
1262 * error. | |
1263 * | |
1264 * If the used [http.Client] completes with an error when making a REST call, | |
1265 * this method will complete with the same error. | |
1266 */ | |
1267 async.Future<CryptoKeyVersion> restore(RestoreCryptoKeyVersionRequest request,
core.String name) { | |
1268 var _url = null; | |
1269 var _queryParams = new core.Map(); | |
1270 var _uploadMedia = null; | |
1271 var _uploadOptions = null; | |
1272 var _downloadOptions = commons.DownloadOptions.Metadata; | |
1273 var _body = null; | |
1274 | |
1275 if (request != null) { | |
1276 _body = convert.JSON.encode((request).toJson()); | |
1277 } | |
1278 if (name == null) { | |
1279 throw new core.ArgumentError("Parameter name is required."); | |
1280 } | |
1281 | |
1282 _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + ':resto
re'; | |
1283 | |
1284 var _response = _requester.request(_url, | |
1285 "POST", | |
1286 body: _body, | |
1287 queryParams: _queryParams, | |
1288 uploadOptions: _uploadOptions, | |
1289 uploadMedia: _uploadMedia, | |
1290 downloadOptions: _downloadOptions); | |
1291 return _response.then((data) => new CryptoKeyVersion.fromJson(data)); | |
1292 } | |
1293 | |
1294 } | |
1295 | |
1296 | |
1297 | |
1298 /** | |
1299 * Specifies the audit configuration for a service. | |
1300 * It consists of which permission types are logged, and what identities, if | |
1301 * any, are exempted from logging. | |
1302 * An AuditConifg must have one or more AuditLogConfigs. | |
1303 * | |
1304 * If there are AuditConfigs for both `allServices` and a specific service, | |
1305 * the union of the two AuditConfigs is used for that service: the log_types | |
1306 * specified in each AuditConfig are enabled, and the exempted_members in each | |
1307 * AuditConfig are exempted. | |
1308 * Example Policy with multiple AuditConfigs: | |
1309 * { | |
1310 * "audit_configs": [ | |
1311 * { | |
1312 * "service": "allServices" | |
1313 * "audit_log_configs": [ | |
1314 * { | |
1315 * "log_type": "DATA_READ", | |
1316 * "exempted_members": [ | |
1317 * "user:foo@gmail.com" | |
1318 * ] | |
1319 * }, | |
1320 * { | |
1321 * "log_type": "DATA_WRITE", | |
1322 * }, | |
1323 * { | |
1324 * "log_type": "ADMIN_READ", | |
1325 * } | |
1326 * ] | |
1327 * }, | |
1328 * { | |
1329 * "service": "fooservice@googleapis.com" | |
1330 * "audit_log_configs": [ | |
1331 * { | |
1332 * "log_type": "DATA_READ", | |
1333 * }, | |
1334 * { | |
1335 * "log_type": "DATA_WRITE", | |
1336 * "exempted_members": [ | |
1337 * "user:bar@gmail.com" | |
1338 * ] | |
1339 * } | |
1340 * ] | |
1341 * } | |
1342 * ] | |
1343 * } | |
1344 * For fooservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ | |
1345 * logging. It also exempts foo@gmail.com from DATA_READ logging, and | |
1346 * bar@gmail.com from DATA_WRITE logging. | |
1347 */ | |
1348 class AuditConfig { | |
1349 /** | |
1350 * The configuration for logging of each type of permission. | |
1351 * Next ID: 4 | |
1352 */ | |
1353 core.List<AuditLogConfig> auditLogConfigs; | |
1354 core.List<core.String> exemptedMembers; | |
1355 /** | |
1356 * Specifies a service that will be enabled for audit logging. | |
1357 * For example, `resourcemanager`, `storage`, `compute`. | |
1358 * `allServices` is a special value that covers all services. | |
1359 */ | |
1360 core.String service; | |
1361 | |
1362 AuditConfig(); | |
1363 | |
1364 AuditConfig.fromJson(core.Map _json) { | |
1365 if (_json.containsKey("auditLogConfigs")) { | |
1366 auditLogConfigs = _json["auditLogConfigs"].map((value) => new AuditLogConf
ig.fromJson(value)).toList(); | |
1367 } | |
1368 if (_json.containsKey("exemptedMembers")) { | |
1369 exemptedMembers = _json["exemptedMembers"]; | |
1370 } | |
1371 if (_json.containsKey("service")) { | |
1372 service = _json["service"]; | |
1373 } | |
1374 } | |
1375 | |
1376 core.Map toJson() { | |
1377 var _json = new core.Map(); | |
1378 if (auditLogConfigs != null) { | |
1379 _json["auditLogConfigs"] = auditLogConfigs.map((value) => (value).toJson()
).toList(); | |
1380 } | |
1381 if (exemptedMembers != null) { | |
1382 _json["exemptedMembers"] = exemptedMembers; | |
1383 } | |
1384 if (service != null) { | |
1385 _json["service"] = service; | |
1386 } | |
1387 return _json; | |
1388 } | |
1389 } | |
1390 | |
1391 /** | |
1392 * Provides the configuration for logging a type of permissions. | |
1393 * Example: | |
1394 * | |
1395 * { | |
1396 * "audit_log_configs": [ | |
1397 * { | |
1398 * "log_type": "DATA_READ", | |
1399 * "exempted_members": [ | |
1400 * "user:foo@gmail.com" | |
1401 * ] | |
1402 * }, | |
1403 * { | |
1404 * "log_type": "DATA_WRITE", | |
1405 * } | |
1406 * ] | |
1407 * } | |
1408 * | |
1409 * This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting | |
1410 * foo@gmail.com from DATA_READ logging. | |
1411 */ | |
1412 class AuditLogConfig { | |
1413 /** | |
1414 * Specifies the identities that do not cause logging for this type of | |
1415 * permission. | |
1416 * Follows the same format of Binding.members. | |
1417 */ | |
1418 core.List<core.String> exemptedMembers; | |
1419 /** | |
1420 * The log type that this config enables. | |
1421 * Possible string values are: | |
1422 * - "LOG_TYPE_UNSPECIFIED" : Default case. Should never be this. | |
1423 * - "ADMIN_READ" : Admin reads. Example: CloudIAM getIamPolicy | |
1424 * - "DATA_WRITE" : Data writes. Example: CloudSQL Users create | |
1425 * - "DATA_READ" : Data reads. Example: CloudSQL Users list | |
1426 */ | |
1427 core.String logType; | |
1428 | |
1429 AuditLogConfig(); | |
1430 | |
1431 AuditLogConfig.fromJson(core.Map _json) { | |
1432 if (_json.containsKey("exemptedMembers")) { | |
1433 exemptedMembers = _json["exemptedMembers"]; | |
1434 } | |
1435 if (_json.containsKey("logType")) { | |
1436 logType = _json["logType"]; | |
1437 } | |
1438 } | |
1439 | |
1440 core.Map toJson() { | |
1441 var _json = new core.Map(); | |
1442 if (exemptedMembers != null) { | |
1443 _json["exemptedMembers"] = exemptedMembers; | |
1444 } | |
1445 if (logType != null) { | |
1446 _json["logType"] = logType; | |
1447 } | |
1448 return _json; | |
1449 } | |
1450 } | |
1451 | |
1452 /** Associates `members` with a `role`. */ | |
1453 class Binding { | |
1454 /** | |
1455 * Specifies the identities requesting access for a Cloud Platform resource. | |
1456 * `members` can have the following values: | |
1457 * | |
1458 * * `allUsers`: A special identifier that represents anyone who is | |
1459 * on the internet; with or without a Google account. | |
1460 * | |
1461 * * `allAuthenticatedUsers`: A special identifier that represents anyone | |
1462 * who is authenticated with a Google account or a service account. | |
1463 * | |
1464 * * `user:{emailid}`: An email address that represents a specific Google | |
1465 * account. For example, `alice@gmail.com` or `joe@example.com`. | |
1466 * | |
1467 * | |
1468 * * `serviceAccount:{emailid}`: An email address that represents a service | |
1469 * account. For example, `my-other-app@appspot.gserviceaccount.com`. | |
1470 * | |
1471 * * `group:{emailid}`: An email address that represents a Google group. | |
1472 * For example, `admins@example.com`. | |
1473 * | |
1474 * * `domain:{domain}`: A Google Apps domain name that represents all the | |
1475 * users of that domain. For example, `google.com` or `example.com`. | |
1476 */ | |
1477 core.List<core.String> members; | |
1478 /** | |
1479 * Role that is assigned to `members`. | |
1480 * For example, `roles/viewer`, `roles/editor`, or `roles/owner`. | |
1481 * Required | |
1482 */ | |
1483 core.String role; | |
1484 | |
1485 Binding(); | |
1486 | |
1487 Binding.fromJson(core.Map _json) { | |
1488 if (_json.containsKey("members")) { | |
1489 members = _json["members"]; | |
1490 } | |
1491 if (_json.containsKey("role")) { | |
1492 role = _json["role"]; | |
1493 } | |
1494 } | |
1495 | |
1496 core.Map toJson() { | |
1497 var _json = new core.Map(); | |
1498 if (members != null) { | |
1499 _json["members"] = members; | |
1500 } | |
1501 if (role != null) { | |
1502 _json["role"] = role; | |
1503 } | |
1504 return _json; | |
1505 } | |
1506 } | |
1507 | |
1508 /** Write a Cloud Audit log */ | |
1509 class CloudAuditOptions { | |
1510 | |
1511 CloudAuditOptions(); | |
1512 | |
1513 CloudAuditOptions.fromJson(core.Map _json) { | |
1514 } | |
1515 | |
1516 core.Map toJson() { | |
1517 var _json = new core.Map(); | |
1518 return _json; | |
1519 } | |
1520 } | |
1521 | |
1522 /** A condition to be met. */ | |
1523 class Condition { | |
1524 /** | |
1525 * Trusted attributes supplied by the IAM system. | |
1526 * Possible string values are: | |
1527 * - "NO_ATTR" : Default non-attribute. | |
1528 * - "AUTHORITY" : Either principal or (if present) authority selector. | |
1529 * - "ATTRIBUTION" : The principal (even if an authority selector is present), | |
1530 * which | |
1531 * must only be used for attribution, not authorization. | |
1532 * - "APPROVER" : An approver (distinct from the requester) that has | |
1533 * authorized this | |
1534 * request. | |
1535 * When used with IN, the condition indicates that one of the approvers | |
1536 * associated with the request matches the specified principal, or is a | |
1537 * member of the specified group. Approvers can only grant additional | |
1538 * access, and are thus only used in a strictly positive context | |
1539 * (e.g. ALLOW/IN or DENY/NOT_IN). | |
1540 * See: go/rpc-security-policy-dynamicauth. | |
1541 */ | |
1542 core.String iam; | |
1543 /** | |
1544 * An operator to apply the subject with. | |
1545 * Possible string values are: | |
1546 * - "NO_OP" : Default no-op. | |
1547 * - "EQUALS" : DEPRECATED. Use IN instead. | |
1548 * - "NOT_EQUALS" : DEPRECATED. Use NOT_IN instead. | |
1549 * - "IN" : Set-inclusion check. | |
1550 * - "NOT_IN" : Set-exclusion check. | |
1551 * - "DISCHARGED" : Subject is discharged | |
1552 */ | |
1553 core.String op; | |
1554 /** Trusted attributes discharged by the service. */ | |
1555 core.String svc; | |
1556 /** | |
1557 * Trusted attributes supplied by any service that owns resources and uses | |
1558 * the IAM system for access control. | |
1559 * Possible string values are: | |
1560 * - "NO_ATTR" : Default non-attribute type | |
1561 * - "REGION" : Region of the resource | |
1562 * - "SERVICE" : Service name | |
1563 * - "NAME" : Resource name | |
1564 * - "IP" : IP address of the caller | |
1565 */ | |
1566 core.String sys; | |
1567 /** DEPRECATED. Use 'values' instead. */ | |
1568 core.String value; | |
1569 /** The objects of the condition. This is mutually exclusive with 'value'. */ | |
1570 core.List<core.String> values; | |
1571 | |
1572 Condition(); | |
1573 | |
1574 Condition.fromJson(core.Map _json) { | |
1575 if (_json.containsKey("iam")) { | |
1576 iam = _json["iam"]; | |
1577 } | |
1578 if (_json.containsKey("op")) { | |
1579 op = _json["op"]; | |
1580 } | |
1581 if (_json.containsKey("svc")) { | |
1582 svc = _json["svc"]; | |
1583 } | |
1584 if (_json.containsKey("sys")) { | |
1585 sys = _json["sys"]; | |
1586 } | |
1587 if (_json.containsKey("value")) { | |
1588 value = _json["value"]; | |
1589 } | |
1590 if (_json.containsKey("values")) { | |
1591 values = _json["values"]; | |
1592 } | |
1593 } | |
1594 | |
1595 core.Map toJson() { | |
1596 var _json = new core.Map(); | |
1597 if (iam != null) { | |
1598 _json["iam"] = iam; | |
1599 } | |
1600 if (op != null) { | |
1601 _json["op"] = op; | |
1602 } | |
1603 if (svc != null) { | |
1604 _json["svc"] = svc; | |
1605 } | |
1606 if (sys != null) { | |
1607 _json["sys"] = sys; | |
1608 } | |
1609 if (value != null) { | |
1610 _json["value"] = value; | |
1611 } | |
1612 if (values != null) { | |
1613 _json["values"] = values; | |
1614 } | |
1615 return _json; | |
1616 } | |
1617 } | |
1618 | |
1619 /** Options for counters */ | |
1620 class CounterOptions { | |
1621 /** The field value to attribute. */ | |
1622 core.String field; | |
1623 /** The metric to update. */ | |
1624 core.String metric; | |
1625 | |
1626 CounterOptions(); | |
1627 | |
1628 CounterOptions.fromJson(core.Map _json) { | |
1629 if (_json.containsKey("field")) { | |
1630 field = _json["field"]; | |
1631 } | |
1632 if (_json.containsKey("metric")) { | |
1633 metric = _json["metric"]; | |
1634 } | |
1635 } | |
1636 | |
1637 core.Map toJson() { | |
1638 var _json = new core.Map(); | |
1639 if (field != null) { | |
1640 _json["field"] = field; | |
1641 } | |
1642 if (metric != null) { | |
1643 _json["metric"] = metric; | |
1644 } | |
1645 return _json; | |
1646 } | |
1647 } | |
1648 | |
1649 /** | |
1650 * A CryptoKey represents a logical key that can be used for cryptographic | |
1651 * operations. | |
1652 * | |
1653 * A CryptoKey is made up of one or more versions, which | |
1654 * represent the actual key material used in cryptographic operations. | |
1655 */ | |
1656 class CryptoKey { | |
1657 /** Output only. The time at which this CryptoKey was created. */ | |
1658 core.String createTime; | |
1659 /** | |
1660 * Output only. The resource name for this CryptoKey in the format | |
1661 * `projects / * /locations / * /keyRings / * /cryptoKeys / * `. | |
1662 */ | |
1663 core.String name; | |
1664 /** | |
1665 * At next_rotation_time, the Key Management Service will automatically: | |
1666 * | |
1667 * 1. Create a new version of this CryptoKey. | |
1668 * 2. Mark the new version as primary. | |
1669 * | |
1670 * Key rotations performed manually via | |
1671 * CreateCryptoKeyVersion and | |
1672 * UpdateCryptoKeyPrimaryVersion | |
1673 * do not affect next_rotation_time. | |
1674 */ | |
1675 core.String nextRotationTime; | |
1676 /** | |
1677 * Output only. A copy of the "primary" CryptoKeyVersion that will be used | |
1678 * by Encrypt when this CryptoKey is given | |
1679 * in EncryptRequest.name. | |
1680 * | |
1681 * The CryptoKey's primary version can be updated via | |
1682 * UpdateCryptoKeyPrimaryVersion. | |
1683 */ | |
1684 CryptoKeyVersion primary; | |
1685 /** | |
1686 * The immutable purpose of this CryptoKey. Currently, the only acceptable | |
1687 * purpose is ENCRYPT_DECRYPT. | |
1688 * Possible string values are: | |
1689 * - "CRYPTO_KEY_PURPOSE_UNSPECIFIED" : Not specified. | |
1690 * - "ENCRYPT_DECRYPT" : CryptoKeys with this purpose may be used with | |
1691 * Encrypt and | |
1692 * Decrypt. | |
1693 */ | |
1694 core.String purpose; | |
1695 /** | |
1696 * next_rotation_time will be advanced by this period when the service | |
1697 * automatically rotates a key. Must be at least one day. | |
1698 * | |
1699 * If rotation_period is set, next_rotation_time must also be set. | |
1700 */ | |
1701 core.String rotationPeriod; | |
1702 | |
1703 CryptoKey(); | |
1704 | |
1705 CryptoKey.fromJson(core.Map _json) { | |
1706 if (_json.containsKey("createTime")) { | |
1707 createTime = _json["createTime"]; | |
1708 } | |
1709 if (_json.containsKey("name")) { | |
1710 name = _json["name"]; | |
1711 } | |
1712 if (_json.containsKey("nextRotationTime")) { | |
1713 nextRotationTime = _json["nextRotationTime"]; | |
1714 } | |
1715 if (_json.containsKey("primary")) { | |
1716 primary = new CryptoKeyVersion.fromJson(_json["primary"]); | |
1717 } | |
1718 if (_json.containsKey("purpose")) { | |
1719 purpose = _json["purpose"]; | |
1720 } | |
1721 if (_json.containsKey("rotationPeriod")) { | |
1722 rotationPeriod = _json["rotationPeriod"]; | |
1723 } | |
1724 } | |
1725 | |
1726 core.Map toJson() { | |
1727 var _json = new core.Map(); | |
1728 if (createTime != null) { | |
1729 _json["createTime"] = createTime; | |
1730 } | |
1731 if (name != null) { | |
1732 _json["name"] = name; | |
1733 } | |
1734 if (nextRotationTime != null) { | |
1735 _json["nextRotationTime"] = nextRotationTime; | |
1736 } | |
1737 if (primary != null) { | |
1738 _json["primary"] = (primary).toJson(); | |
1739 } | |
1740 if (purpose != null) { | |
1741 _json["purpose"] = purpose; | |
1742 } | |
1743 if (rotationPeriod != null) { | |
1744 _json["rotationPeriod"] = rotationPeriod; | |
1745 } | |
1746 return _json; | |
1747 } | |
1748 } | |
1749 | |
1750 /** | |
1751 * A CryptoKeyVersion represents an individual cryptographic key, and the | |
1752 * associated key material. | |
1753 * | |
1754 * It can be used for cryptographic operations either directly, or via its | |
1755 * parent CryptoKey, in which case the server will choose the appropriate | |
1756 * version for the operation. | |
1757 */ | |
1758 class CryptoKeyVersion { | |
1759 /** Output only. The time at which this CryptoKeyVersion was created. */ | |
1760 core.String createTime; | |
1761 /** | |
1762 * Output only. The time this CryptoKeyVersion's key material was | |
1763 * destroyed. Only present if state is | |
1764 * DESTROYED. | |
1765 */ | |
1766 core.String destroyEventTime; | |
1767 /** | |
1768 * Output only. The time this CryptoKeyVersion's key material is scheduled | |
1769 * for destruction. Only present if state is | |
1770 * DESTROY_SCHEDULED. | |
1771 */ | |
1772 core.String destroyTime; | |
1773 /** | |
1774 * Output only. The resource name for this CryptoKeyVersion in the format | |
1775 * `projects / * /locations / * /keyRings / * /cryptoKeys / * | |
1776 * /cryptoKeyVersions / * `. | |
1777 */ | |
1778 core.String name; | |
1779 /** | |
1780 * The current state of the CryptoKeyVersion. | |
1781 * Possible string values are: | |
1782 * - "CRYPTO_KEY_VERSION_STATE_UNSPECIFIED" : Not specified. | |
1783 * - "ENABLED" : This version may be used in Encrypt and | |
1784 * Decrypt requests. | |
1785 * - "DISABLED" : This version may not be used, but the key material is still | |
1786 * available, | |
1787 * and the version can be placed back into the ENABLED state. | |
1788 * - "DESTROYED" : This version is destroyed, and the key material is no | |
1789 * longer stored. | |
1790 * A version may not leave this state once entered. | |
1791 * - "DESTROY_SCHEDULED" : This version is scheduled for destruction, and will | |
1792 * be destroyed soon. | |
1793 * Call | |
1794 * RestoreCryptoKeyVersion | |
1795 * to put it back into the DISABLED state. | |
1796 */ | |
1797 core.String state; | |
1798 | |
1799 CryptoKeyVersion(); | |
1800 | |
1801 CryptoKeyVersion.fromJson(core.Map _json) { | |
1802 if (_json.containsKey("createTime")) { | |
1803 createTime = _json["createTime"]; | |
1804 } | |
1805 if (_json.containsKey("destroyEventTime")) { | |
1806 destroyEventTime = _json["destroyEventTime"]; | |
1807 } | |
1808 if (_json.containsKey("destroyTime")) { | |
1809 destroyTime = _json["destroyTime"]; | |
1810 } | |
1811 if (_json.containsKey("name")) { | |
1812 name = _json["name"]; | |
1813 } | |
1814 if (_json.containsKey("state")) { | |
1815 state = _json["state"]; | |
1816 } | |
1817 } | |
1818 | |
1819 core.Map toJson() { | |
1820 var _json = new core.Map(); | |
1821 if (createTime != null) { | |
1822 _json["createTime"] = createTime; | |
1823 } | |
1824 if (destroyEventTime != null) { | |
1825 _json["destroyEventTime"] = destroyEventTime; | |
1826 } | |
1827 if (destroyTime != null) { | |
1828 _json["destroyTime"] = destroyTime; | |
1829 } | |
1830 if (name != null) { | |
1831 _json["name"] = name; | |
1832 } | |
1833 if (state != null) { | |
1834 _json["state"] = state; | |
1835 } | |
1836 return _json; | |
1837 } | |
1838 } | |
1839 | |
1840 /** Write a Data Access (Gin) log */ | |
1841 class DataAccessOptions { | |
1842 | |
1843 DataAccessOptions(); | |
1844 | |
1845 DataAccessOptions.fromJson(core.Map _json) { | |
1846 } | |
1847 | |
1848 core.Map toJson() { | |
1849 var _json = new core.Map(); | |
1850 return _json; | |
1851 } | |
1852 } | |
1853 | |
1854 /** Request message for KeyManagementService.Decrypt. */ | |
1855 class DecryptRequest { | |
1856 /** | |
1857 * Optional data that must match the data originally supplied in | |
1858 * EncryptRequest.additional_authenticated_data. | |
1859 */ | |
1860 core.String additionalAuthenticatedData; | |
1861 core.List<core.int> get additionalAuthenticatedDataAsBytes { | |
1862 return convert.BASE64.decode(additionalAuthenticatedData); | |
1863 } | |
1864 | |
1865 void set additionalAuthenticatedDataAsBytes(core.List<core.int> _bytes) { | |
1866 additionalAuthenticatedData = convert.BASE64.encode(_bytes).replaceAll("/",
"_").replaceAll("+", "-"); | |
1867 } | |
1868 /** | |
1869 * Required. The encrypted data originally returned in | |
1870 * EncryptResponse.ciphertext. | |
1871 */ | |
1872 core.String ciphertext; | |
1873 core.List<core.int> get ciphertextAsBytes { | |
1874 return convert.BASE64.decode(ciphertext); | |
1875 } | |
1876 | |
1877 void set ciphertextAsBytes(core.List<core.int> _bytes) { | |
1878 ciphertext = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("
+", "-"); | |
1879 } | |
1880 | |
1881 DecryptRequest(); | |
1882 | |
1883 DecryptRequest.fromJson(core.Map _json) { | |
1884 if (_json.containsKey("additionalAuthenticatedData")) { | |
1885 additionalAuthenticatedData = _json["additionalAuthenticatedData"]; | |
1886 } | |
1887 if (_json.containsKey("ciphertext")) { | |
1888 ciphertext = _json["ciphertext"]; | |
1889 } | |
1890 } | |
1891 | |
1892 core.Map toJson() { | |
1893 var _json = new core.Map(); | |
1894 if (additionalAuthenticatedData != null) { | |
1895 _json["additionalAuthenticatedData"] = additionalAuthenticatedData; | |
1896 } | |
1897 if (ciphertext != null) { | |
1898 _json["ciphertext"] = ciphertext; | |
1899 } | |
1900 return _json; | |
1901 } | |
1902 } | |
1903 | |
1904 /** Response message for KeyManagementService.Decrypt. */ | |
1905 class DecryptResponse { | |
1906 /** The decrypted data originally supplied in EncryptRequest.plaintext. */ | |
1907 core.String plaintext; | |
1908 core.List<core.int> get plaintextAsBytes { | |
1909 return convert.BASE64.decode(plaintext); | |
1910 } | |
1911 | |
1912 void set plaintextAsBytes(core.List<core.int> _bytes) { | |
1913 plaintext = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+
", "-"); | |
1914 } | |
1915 | |
1916 DecryptResponse(); | |
1917 | |
1918 DecryptResponse.fromJson(core.Map _json) { | |
1919 if (_json.containsKey("plaintext")) { | |
1920 plaintext = _json["plaintext"]; | |
1921 } | |
1922 } | |
1923 | |
1924 core.Map toJson() { | |
1925 var _json = new core.Map(); | |
1926 if (plaintext != null) { | |
1927 _json["plaintext"] = plaintext; | |
1928 } | |
1929 return _json; | |
1930 } | |
1931 } | |
1932 | |
1933 /** Request message for KeyManagementService.DestroyCryptoKeyVersion. */ | |
1934 class DestroyCryptoKeyVersionRequest { | |
1935 | |
1936 DestroyCryptoKeyVersionRequest(); | |
1937 | |
1938 DestroyCryptoKeyVersionRequest.fromJson(core.Map _json) { | |
1939 } | |
1940 | |
1941 core.Map toJson() { | |
1942 var _json = new core.Map(); | |
1943 return _json; | |
1944 } | |
1945 } | |
1946 | |
1947 /** Request message for KeyManagementService.Encrypt. */ | |
1948 class EncryptRequest { | |
1949 /** | |
1950 * Optional data that, if specified, must also be provided during decryption | |
1951 * through DecryptRequest.additional_authenticated_data. Must be no | |
1952 * larger than 64KiB. | |
1953 */ | |
1954 core.String additionalAuthenticatedData; | |
1955 core.List<core.int> get additionalAuthenticatedDataAsBytes { | |
1956 return convert.BASE64.decode(additionalAuthenticatedData); | |
1957 } | |
1958 | |
1959 void set additionalAuthenticatedDataAsBytes(core.List<core.int> _bytes) { | |
1960 additionalAuthenticatedData = convert.BASE64.encode(_bytes).replaceAll("/",
"_").replaceAll("+", "-"); | |
1961 } | |
1962 /** Required. The data to encrypt. Must be no larger than 64KiB. */ | |
1963 core.String plaintext; | |
1964 core.List<core.int> get plaintextAsBytes { | |
1965 return convert.BASE64.decode(plaintext); | |
1966 } | |
1967 | |
1968 void set plaintextAsBytes(core.List<core.int> _bytes) { | |
1969 plaintext = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+
", "-"); | |
1970 } | |
1971 | |
1972 EncryptRequest(); | |
1973 | |
1974 EncryptRequest.fromJson(core.Map _json) { | |
1975 if (_json.containsKey("additionalAuthenticatedData")) { | |
1976 additionalAuthenticatedData = _json["additionalAuthenticatedData"]; | |
1977 } | |
1978 if (_json.containsKey("plaintext")) { | |
1979 plaintext = _json["plaintext"]; | |
1980 } | |
1981 } | |
1982 | |
1983 core.Map toJson() { | |
1984 var _json = new core.Map(); | |
1985 if (additionalAuthenticatedData != null) { | |
1986 _json["additionalAuthenticatedData"] = additionalAuthenticatedData; | |
1987 } | |
1988 if (plaintext != null) { | |
1989 _json["plaintext"] = plaintext; | |
1990 } | |
1991 return _json; | |
1992 } | |
1993 } | |
1994 | |
1995 /** Response message for KeyManagementService.Encrypt. */ | |
1996 class EncryptResponse { | |
1997 /** The encrypted data. */ | |
1998 core.String ciphertext; | |
1999 core.List<core.int> get ciphertextAsBytes { | |
2000 return convert.BASE64.decode(ciphertext); | |
2001 } | |
2002 | |
2003 void set ciphertextAsBytes(core.List<core.int> _bytes) { | |
2004 ciphertext = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("
+", "-"); | |
2005 } | |
2006 /** The resource name of the CryptoKeyVersion used in encryption. */ | |
2007 core.String name; | |
2008 | |
2009 EncryptResponse(); | |
2010 | |
2011 EncryptResponse.fromJson(core.Map _json) { | |
2012 if (_json.containsKey("ciphertext")) { | |
2013 ciphertext = _json["ciphertext"]; | |
2014 } | |
2015 if (_json.containsKey("name")) { | |
2016 name = _json["name"]; | |
2017 } | |
2018 } | |
2019 | |
2020 core.Map toJson() { | |
2021 var _json = new core.Map(); | |
2022 if (ciphertext != null) { | |
2023 _json["ciphertext"] = ciphertext; | |
2024 } | |
2025 if (name != null) { | |
2026 _json["name"] = name; | |
2027 } | |
2028 return _json; | |
2029 } | |
2030 } | |
2031 | |
2032 /** A KeyRing is a toplevel logical grouping of CryptoKeys. */ | |
2033 class KeyRing { | |
2034 /** Output only. The time at which this KeyRing was created. */ | |
2035 core.String createTime; | |
2036 /** | |
2037 * Output only. The resource name for the KeyRing in the format | |
2038 * `projects / * /locations / * /keyRings / * `. | |
2039 */ | |
2040 core.String name; | |
2041 | |
2042 KeyRing(); | |
2043 | |
2044 KeyRing.fromJson(core.Map _json) { | |
2045 if (_json.containsKey("createTime")) { | |
2046 createTime = _json["createTime"]; | |
2047 } | |
2048 if (_json.containsKey("name")) { | |
2049 name = _json["name"]; | |
2050 } | |
2051 } | |
2052 | |
2053 core.Map toJson() { | |
2054 var _json = new core.Map(); | |
2055 if (createTime != null) { | |
2056 _json["createTime"] = createTime; | |
2057 } | |
2058 if (name != null) { | |
2059 _json["name"] = name; | |
2060 } | |
2061 return _json; | |
2062 } | |
2063 } | |
2064 | |
2065 /** Response message for KeyManagementService.ListCryptoKeyVersions. */ | |
2066 class ListCryptoKeyVersionsResponse { | |
2067 /** The list of CryptoKeyVersions. */ | |
2068 core.List<CryptoKeyVersion> cryptoKeyVersions; | |
2069 /** | |
2070 * A token to retrieve next page of results. Pass this value in | |
2071 * ListCryptoKeyVersionsRequest.page_token to retrieve the next page of | |
2072 * results. | |
2073 */ | |
2074 core.String nextPageToken; | |
2075 /** | |
2076 * The total number of CryptoKeyVersions that matched the | |
2077 * query. | |
2078 */ | |
2079 core.int totalSize; | |
2080 | |
2081 ListCryptoKeyVersionsResponse(); | |
2082 | |
2083 ListCryptoKeyVersionsResponse.fromJson(core.Map _json) { | |
2084 if (_json.containsKey("cryptoKeyVersions")) { | |
2085 cryptoKeyVersions = _json["cryptoKeyVersions"].map((value) => new CryptoKe
yVersion.fromJson(value)).toList(); | |
2086 } | |
2087 if (_json.containsKey("nextPageToken")) { | |
2088 nextPageToken = _json["nextPageToken"]; | |
2089 } | |
2090 if (_json.containsKey("totalSize")) { | |
2091 totalSize = _json["totalSize"]; | |
2092 } | |
2093 } | |
2094 | |
2095 core.Map toJson() { | |
2096 var _json = new core.Map(); | |
2097 if (cryptoKeyVersions != null) { | |
2098 _json["cryptoKeyVersions"] = cryptoKeyVersions.map((value) => (value).toJs
on()).toList(); | |
2099 } | |
2100 if (nextPageToken != null) { | |
2101 _json["nextPageToken"] = nextPageToken; | |
2102 } | |
2103 if (totalSize != null) { | |
2104 _json["totalSize"] = totalSize; | |
2105 } | |
2106 return _json; | |
2107 } | |
2108 } | |
2109 | |
2110 /** Response message for KeyManagementService.ListCryptoKeys. */ | |
2111 class ListCryptoKeysResponse { | |
2112 /** The list of CryptoKeys. */ | |
2113 core.List<CryptoKey> cryptoKeys; | |
2114 /** | |
2115 * A token to retrieve next page of results. Pass this value in | |
2116 * ListCryptoKeysRequest.page_token to retrieve the next page of results. | |
2117 */ | |
2118 core.String nextPageToken; | |
2119 /** The total number of CryptoKeys that matched the query. */ | |
2120 core.int totalSize; | |
2121 | |
2122 ListCryptoKeysResponse(); | |
2123 | |
2124 ListCryptoKeysResponse.fromJson(core.Map _json) { | |
2125 if (_json.containsKey("cryptoKeys")) { | |
2126 cryptoKeys = _json["cryptoKeys"].map((value) => new CryptoKey.fromJson(val
ue)).toList(); | |
2127 } | |
2128 if (_json.containsKey("nextPageToken")) { | |
2129 nextPageToken = _json["nextPageToken"]; | |
2130 } | |
2131 if (_json.containsKey("totalSize")) { | |
2132 totalSize = _json["totalSize"]; | |
2133 } | |
2134 } | |
2135 | |
2136 core.Map toJson() { | |
2137 var _json = new core.Map(); | |
2138 if (cryptoKeys != null) { | |
2139 _json["cryptoKeys"] = cryptoKeys.map((value) => (value).toJson()).toList()
; | |
2140 } | |
2141 if (nextPageToken != null) { | |
2142 _json["nextPageToken"] = nextPageToken; | |
2143 } | |
2144 if (totalSize != null) { | |
2145 _json["totalSize"] = totalSize; | |
2146 } | |
2147 return _json; | |
2148 } | |
2149 } | |
2150 | |
2151 /** Response message for KeyManagementService.ListKeyRings. */ | |
2152 class ListKeyRingsResponse { | |
2153 /** The list of KeyRings. */ | |
2154 core.List<KeyRing> keyRings; | |
2155 /** | |
2156 * A token to retrieve next page of results. Pass this value in | |
2157 * ListKeyRingsRequest.page_token to retrieve the next page of results. | |
2158 */ | |
2159 core.String nextPageToken; | |
2160 /** The total number of KeyRings that matched the query. */ | |
2161 core.int totalSize; | |
2162 | |
2163 ListKeyRingsResponse(); | |
2164 | |
2165 ListKeyRingsResponse.fromJson(core.Map _json) { | |
2166 if (_json.containsKey("keyRings")) { | |
2167 keyRings = _json["keyRings"].map((value) => new KeyRing.fromJson(value)).t
oList(); | |
2168 } | |
2169 if (_json.containsKey("nextPageToken")) { | |
2170 nextPageToken = _json["nextPageToken"]; | |
2171 } | |
2172 if (_json.containsKey("totalSize")) { | |
2173 totalSize = _json["totalSize"]; | |
2174 } | |
2175 } | |
2176 | |
2177 core.Map toJson() { | |
2178 var _json = new core.Map(); | |
2179 if (keyRings != null) { | |
2180 _json["keyRings"] = keyRings.map((value) => (value).toJson()).toList(); | |
2181 } | |
2182 if (nextPageToken != null) { | |
2183 _json["nextPageToken"] = nextPageToken; | |
2184 } | |
2185 if (totalSize != null) { | |
2186 _json["totalSize"] = totalSize; | |
2187 } | |
2188 return _json; | |
2189 } | |
2190 } | |
2191 | |
2192 /** The response message for Locations.ListLocations. */ | |
2193 class ListLocationsResponse { | |
2194 /** A list of locations that matches the specified filter in the request. */ | |
2195 core.List<Location> locations; | |
2196 /** The standard List next-page token. */ | |
2197 core.String nextPageToken; | |
2198 | |
2199 ListLocationsResponse(); | |
2200 | |
2201 ListLocationsResponse.fromJson(core.Map _json) { | |
2202 if (_json.containsKey("locations")) { | |
2203 locations = _json["locations"].map((value) => new Location.fromJson(value)
).toList(); | |
2204 } | |
2205 if (_json.containsKey("nextPageToken")) { | |
2206 nextPageToken = _json["nextPageToken"]; | |
2207 } | |
2208 } | |
2209 | |
2210 core.Map toJson() { | |
2211 var _json = new core.Map(); | |
2212 if (locations != null) { | |
2213 _json["locations"] = locations.map((value) => (value).toJson()).toList(); | |
2214 } | |
2215 if (nextPageToken != null) { | |
2216 _json["nextPageToken"] = nextPageToken; | |
2217 } | |
2218 return _json; | |
2219 } | |
2220 } | |
2221 | |
2222 /** A resource that represents Google Cloud Platform location. */ | |
2223 class Location { | |
2224 /** | |
2225 * Cross-service attributes for the location. For example | |
2226 * | |
2227 * {"cloud.googleapis.com/region": "us-east1"} | |
2228 */ | |
2229 core.Map<core.String, core.String> labels; | |
2230 /** The canonical id for this location. For example: `"us-east1"`. */ | |
2231 core.String locationId; | |
2232 /** | |
2233 * Service-specific metadata. For example the available capacity at the given | |
2234 * location. | |
2235 * | |
2236 * The values for Object must be JSON objects. It can consist of `num`, | |
2237 * `String`, `bool` and `null` as well as `Map` and `List` values. | |
2238 */ | |
2239 core.Map<core.String, core.Object> metadata; | |
2240 /** | |
2241 * Resource name for the location, which may vary between implementations. | |
2242 * For example: `"projects/example-project/locations/us-east1"` | |
2243 */ | |
2244 core.String name; | |
2245 | |
2246 Location(); | |
2247 | |
2248 Location.fromJson(core.Map _json) { | |
2249 if (_json.containsKey("labels")) { | |
2250 labels = _json["labels"]; | |
2251 } | |
2252 if (_json.containsKey("locationId")) { | |
2253 locationId = _json["locationId"]; | |
2254 } | |
2255 if (_json.containsKey("metadata")) { | |
2256 metadata = _json["metadata"]; | |
2257 } | |
2258 if (_json.containsKey("name")) { | |
2259 name = _json["name"]; | |
2260 } | |
2261 } | |
2262 | |
2263 core.Map toJson() { | |
2264 var _json = new core.Map(); | |
2265 if (labels != null) { | |
2266 _json["labels"] = labels; | |
2267 } | |
2268 if (locationId != null) { | |
2269 _json["locationId"] = locationId; | |
2270 } | |
2271 if (metadata != null) { | |
2272 _json["metadata"] = metadata; | |
2273 } | |
2274 if (name != null) { | |
2275 _json["name"] = name; | |
2276 } | |
2277 return _json; | |
2278 } | |
2279 } | |
2280 | |
2281 /** | |
2282 * Specifies what kind of log the caller must write | |
2283 * Increment a streamz counter with the specified metric and field names. | |
2284 * | |
2285 * Metric names should start with a '/', generally be lowercase-only, | |
2286 * and end in "_count". Field names should not contain an initial slash. | |
2287 * The actual exported metric names will have "/iam/policy" prepended. | |
2288 * | |
2289 * Field names correspond to IAM request parameters and field values are | |
2290 * their respective values. | |
2291 * | |
2292 * At present the only supported field names are | |
2293 * - "iam_principal", corresponding to IAMContext.principal; | |
2294 * - "" (empty string), resulting in one aggretated counter with no field. | |
2295 * | |
2296 * Examples: | |
2297 * counter { metric: "/debug_access_count" field: "iam_principal" } | |
2298 * ==> increment counter /iam/policy/backend_debug_access_count | |
2299 * {iam_principal=[value of IAMContext.principal]} | |
2300 * | |
2301 * At this time we do not support: | |
2302 * * multiple field names (though this may be supported in the future) | |
2303 * * decrementing the counter | |
2304 * * incrementing it by anything other than 1 | |
2305 */ | |
2306 class LogConfig { | |
2307 /** Cloud audit options. */ | |
2308 CloudAuditOptions cloudAudit; | |
2309 /** Counter options. */ | |
2310 CounterOptions counter; | |
2311 /** Data access options. */ | |
2312 DataAccessOptions dataAccess; | |
2313 | |
2314 LogConfig(); | |
2315 | |
2316 LogConfig.fromJson(core.Map _json) { | |
2317 if (_json.containsKey("cloudAudit")) { | |
2318 cloudAudit = new CloudAuditOptions.fromJson(_json["cloudAudit"]); | |
2319 } | |
2320 if (_json.containsKey("counter")) { | |
2321 counter = new CounterOptions.fromJson(_json["counter"]); | |
2322 } | |
2323 if (_json.containsKey("dataAccess")) { | |
2324 dataAccess = new DataAccessOptions.fromJson(_json["dataAccess"]); | |
2325 } | |
2326 } | |
2327 | |
2328 core.Map toJson() { | |
2329 var _json = new core.Map(); | |
2330 if (cloudAudit != null) { | |
2331 _json["cloudAudit"] = (cloudAudit).toJson(); | |
2332 } | |
2333 if (counter != null) { | |
2334 _json["counter"] = (counter).toJson(); | |
2335 } | |
2336 if (dataAccess != null) { | |
2337 _json["dataAccess"] = (dataAccess).toJson(); | |
2338 } | |
2339 return _json; | |
2340 } | |
2341 } | |
2342 | |
2343 /** | |
2344 * Defines an Identity and Access Management (IAM) policy. It is used to | |
2345 * specify access control policies for Cloud Platform resources. | |
2346 * | |
2347 * | |
2348 * A `Policy` consists of a list of `bindings`. A `Binding` binds a list of | |
2349 * `members` to a `role`, where the members can be user accounts, Google groups, | |
2350 * Google domains, and service accounts. A `role` is a named list of permissions | |
2351 * defined by IAM. | |
2352 * | |
2353 * **Example** | |
2354 * | |
2355 * { | |
2356 * "bindings": [ | |
2357 * { | |
2358 * "role": "roles/owner", | |
2359 * "members": [ | |
2360 * "user:mike@example.com", | |
2361 * "group:admins@example.com", | |
2362 * "domain:google.com", | |
2363 * "serviceAccount:my-other-app@appspot.gserviceaccount.com", | |
2364 * ] | |
2365 * }, | |
2366 * { | |
2367 * "role": "roles/viewer", | |
2368 * "members": ["user:sean@example.com"] | |
2369 * } | |
2370 * ] | |
2371 * } | |
2372 * | |
2373 * For a description of IAM and its features, see the | |
2374 * [IAM developer's guide](https://cloud.google.com/iam). | |
2375 */ | |
2376 class Policy { | |
2377 /** Specifies cloud audit logging configuration for this policy. */ | |
2378 core.List<AuditConfig> auditConfigs; | |
2379 /** | |
2380 * Associates a list of `members` to a `role`. | |
2381 * Multiple `bindings` must not be specified for the same `role`. | |
2382 * `bindings` with no members will result in an error. | |
2383 */ | |
2384 core.List<Binding> bindings; | |
2385 /** | |
2386 * `etag` is used for optimistic concurrency control as a way to help | |
2387 * prevent simultaneous updates of a policy from overwriting each other. | |
2388 * It is strongly suggested that systems make use of the `etag` in the | |
2389 * read-modify-write cycle to perform policy updates in order to avoid race | |
2390 * conditions: An `etag` is returned in the response to `getIamPolicy`, and | |
2391 * systems are expected to put that etag in the request to `setIamPolicy` to | |
2392 * ensure that their change will be applied to the same version of the policy. | |
2393 * | |
2394 * If no `etag` is provided in the call to `setIamPolicy`, then the existing | |
2395 * policy is overwritten blindly. | |
2396 */ | |
2397 core.String etag; | |
2398 core.List<core.int> get etagAsBytes { | |
2399 return convert.BASE64.decode(etag); | |
2400 } | |
2401 | |
2402 void set etagAsBytes(core.List<core.int> _bytes) { | |
2403 etag = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-
"); | |
2404 } | |
2405 core.bool iamOwned; | |
2406 /** | |
2407 * If more than one rule is specified, the rules are applied in the following | |
2408 * manner: | |
2409 * - All matching LOG rules are always applied. | |
2410 * - If any DENY/DENY_WITH_LOG rule matches, permission is denied. | |
2411 * Logging will be applied if one or more matching rule requires logging. | |
2412 * - Otherwise, if any ALLOW/ALLOW_WITH_LOG rule matches, permission is | |
2413 * granted. | |
2414 * Logging will be applied if one or more matching rule requires logging. | |
2415 * - Otherwise, if no rule applies, permission is denied. | |
2416 */ | |
2417 core.List<Rule> rules; | |
2418 /** Version of the `Policy`. The default version is 0. */ | |
2419 core.int version; | |
2420 | |
2421 Policy(); | |
2422 | |
2423 Policy.fromJson(core.Map _json) { | |
2424 if (_json.containsKey("auditConfigs")) { | |
2425 auditConfigs = _json["auditConfigs"].map((value) => new AuditConfig.fromJs
on(value)).toList(); | |
2426 } | |
2427 if (_json.containsKey("bindings")) { | |
2428 bindings = _json["bindings"].map((value) => new Binding.fromJson(value)).t
oList(); | |
2429 } | |
2430 if (_json.containsKey("etag")) { | |
2431 etag = _json["etag"]; | |
2432 } | |
2433 if (_json.containsKey("iamOwned")) { | |
2434 iamOwned = _json["iamOwned"]; | |
2435 } | |
2436 if (_json.containsKey("rules")) { | |
2437 rules = _json["rules"].map((value) => new Rule.fromJson(value)).toList(); | |
2438 } | |
2439 if (_json.containsKey("version")) { | |
2440 version = _json["version"]; | |
2441 } | |
2442 } | |
2443 | |
2444 core.Map toJson() { | |
2445 var _json = new core.Map(); | |
2446 if (auditConfigs != null) { | |
2447 _json["auditConfigs"] = auditConfigs.map((value) => (value).toJson()).toLi
st(); | |
2448 } | |
2449 if (bindings != null) { | |
2450 _json["bindings"] = bindings.map((value) => (value).toJson()).toList(); | |
2451 } | |
2452 if (etag != null) { | |
2453 _json["etag"] = etag; | |
2454 } | |
2455 if (iamOwned != null) { | |
2456 _json["iamOwned"] = iamOwned; | |
2457 } | |
2458 if (rules != null) { | |
2459 _json["rules"] = rules.map((value) => (value).toJson()).toList(); | |
2460 } | |
2461 if (version != null) { | |
2462 _json["version"] = version; | |
2463 } | |
2464 return _json; | |
2465 } | |
2466 } | |
2467 | |
2468 /** Request message for KeyManagementService.RestoreCryptoKeyVersion. */ | |
2469 class RestoreCryptoKeyVersionRequest { | |
2470 | |
2471 RestoreCryptoKeyVersionRequest(); | |
2472 | |
2473 RestoreCryptoKeyVersionRequest.fromJson(core.Map _json) { | |
2474 } | |
2475 | |
2476 core.Map toJson() { | |
2477 var _json = new core.Map(); | |
2478 return _json; | |
2479 } | |
2480 } | |
2481 | |
2482 /** A rule to be applied in a Policy. */ | |
2483 class Rule { | |
2484 /** | |
2485 * Required | |
2486 * Possible string values are: | |
2487 * - "NO_ACTION" : Default no action. | |
2488 * - "ALLOW" : Matching 'Entries' grant access. | |
2489 * - "ALLOW_WITH_LOG" : Matching 'Entries' grant access and the caller | |
2490 * promises to log | |
2491 * the request per the returned log_configs. | |
2492 * - "DENY" : Matching 'Entries' deny access. | |
2493 * - "DENY_WITH_LOG" : Matching 'Entries' deny access and the caller promises | |
2494 * to log | |
2495 * the request per the returned log_configs. | |
2496 * - "LOG" : Matching 'Entries' tell IAM.Check callers to generate logs. | |
2497 */ | |
2498 core.String action; | |
2499 /** Additional restrictions that must be met */ | |
2500 core.List<Condition> conditions; | |
2501 /** Human-readable description of the rule. */ | |
2502 core.String description; | |
2503 /** | |
2504 * If one or more 'in' clauses are specified, the rule matches if | |
2505 * the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries. | |
2506 */ | |
2507 core.List<core.String> in_; | |
2508 /** | |
2509 * The config returned to callers of tech.iam.IAM.CheckPolicy for any entries | |
2510 * that match the LOG action. | |
2511 */ | |
2512 core.List<LogConfig> logConfig; | |
2513 /** | |
2514 * If one or more 'not_in' clauses are specified, the rule matches | |
2515 * if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. | |
2516 * The format for in and not_in entries is the same as for members in a | |
2517 * Binding (see google/iam/v1/policy.proto). | |
2518 */ | |
2519 core.List<core.String> notIn; | |
2520 /** | |
2521 * A permission is a string of form '<service>.<resource type>.<verb>' | |
2522 * (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, | |
2523 * and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs. | |
2524 */ | |
2525 core.List<core.String> permissions; | |
2526 | |
2527 Rule(); | |
2528 | |
2529 Rule.fromJson(core.Map _json) { | |
2530 if (_json.containsKey("action")) { | |
2531 action = _json["action"]; | |
2532 } | |
2533 if (_json.containsKey("conditions")) { | |
2534 conditions = _json["conditions"].map((value) => new Condition.fromJson(val
ue)).toList(); | |
2535 } | |
2536 if (_json.containsKey("description")) { | |
2537 description = _json["description"]; | |
2538 } | |
2539 if (_json.containsKey("in")) { | |
2540 in_ = _json["in"]; | |
2541 } | |
2542 if (_json.containsKey("logConfig")) { | |
2543 logConfig = _json["logConfig"].map((value) => new LogConfig.fromJson(value
)).toList(); | |
2544 } | |
2545 if (_json.containsKey("notIn")) { | |
2546 notIn = _json["notIn"]; | |
2547 } | |
2548 if (_json.containsKey("permissions")) { | |
2549 permissions = _json["permissions"]; | |
2550 } | |
2551 } | |
2552 | |
2553 core.Map toJson() { | |
2554 var _json = new core.Map(); | |
2555 if (action != null) { | |
2556 _json["action"] = action; | |
2557 } | |
2558 if (conditions != null) { | |
2559 _json["conditions"] = conditions.map((value) => (value).toJson()).toList()
; | |
2560 } | |
2561 if (description != null) { | |
2562 _json["description"] = description; | |
2563 } | |
2564 if (in_ != null) { | |
2565 _json["in"] = in_; | |
2566 } | |
2567 if (logConfig != null) { | |
2568 _json["logConfig"] = logConfig.map((value) => (value).toJson()).toList(); | |
2569 } | |
2570 if (notIn != null) { | |
2571 _json["notIn"] = notIn; | |
2572 } | |
2573 if (permissions != null) { | |
2574 _json["permissions"] = permissions; | |
2575 } | |
2576 return _json; | |
2577 } | |
2578 } | |
2579 | |
2580 /** Request message for `SetIamPolicy` method. */ | |
2581 class SetIamPolicyRequest { | |
2582 /** | |
2583 * REQUIRED: The complete policy to be applied to the `resource`. The size of | |
2584 * the policy is limited to a few 10s of KB. An empty policy is a | |
2585 * valid policy but certain Cloud Platform services (such as Projects) | |
2586 * might reject them. | |
2587 */ | |
2588 Policy policy; | |
2589 /** | |
2590 * OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only | |
2591 * the fields in the mask will be modified. If no mask is provided, a default | |
2592 * mask is used: | |
2593 * paths: "bindings, etag" | |
2594 * This field is only used by Cloud IAM. | |
2595 */ | |
2596 core.String updateMask; | |
2597 | |
2598 SetIamPolicyRequest(); | |
2599 | |
2600 SetIamPolicyRequest.fromJson(core.Map _json) { | |
2601 if (_json.containsKey("policy")) { | |
2602 policy = new Policy.fromJson(_json["policy"]); | |
2603 } | |
2604 if (_json.containsKey("updateMask")) { | |
2605 updateMask = _json["updateMask"]; | |
2606 } | |
2607 } | |
2608 | |
2609 core.Map toJson() { | |
2610 var _json = new core.Map(); | |
2611 if (policy != null) { | |
2612 _json["policy"] = (policy).toJson(); | |
2613 } | |
2614 if (updateMask != null) { | |
2615 _json["updateMask"] = updateMask; | |
2616 } | |
2617 return _json; | |
2618 } | |
2619 } | |
2620 | |
2621 /** Request message for `TestIamPermissions` method. */ | |
2622 class TestIamPermissionsRequest { | |
2623 /** | |
2624 * The set of permissions to check for the `resource`. Permissions with | |
2625 * wildcards (such as '*' or 'storage.*') are not allowed. For more | |
2626 * information see | |
2627 * [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions). | |
2628 */ | |
2629 core.List<core.String> permissions; | |
2630 | |
2631 TestIamPermissionsRequest(); | |
2632 | |
2633 TestIamPermissionsRequest.fromJson(core.Map _json) { | |
2634 if (_json.containsKey("permissions")) { | |
2635 permissions = _json["permissions"]; | |
2636 } | |
2637 } | |
2638 | |
2639 core.Map toJson() { | |
2640 var _json = new core.Map(); | |
2641 if (permissions != null) { | |
2642 _json["permissions"] = permissions; | |
2643 } | |
2644 return _json; | |
2645 } | |
2646 } | |
2647 | |
2648 /** Response message for `TestIamPermissions` method. */ | |
2649 class TestIamPermissionsResponse { | |
2650 /** | |
2651 * A subset of `TestPermissionsRequest.permissions` that the caller is | |
2652 * allowed. | |
2653 */ | |
2654 core.List<core.String> permissions; | |
2655 | |
2656 TestIamPermissionsResponse(); | |
2657 | |
2658 TestIamPermissionsResponse.fromJson(core.Map _json) { | |
2659 if (_json.containsKey("permissions")) { | |
2660 permissions = _json["permissions"]; | |
2661 } | |
2662 } | |
2663 | |
2664 core.Map toJson() { | |
2665 var _json = new core.Map(); | |
2666 if (permissions != null) { | |
2667 _json["permissions"] = permissions; | |
2668 } | |
2669 return _json; | |
2670 } | |
2671 } | |
2672 | |
2673 /** Request message for KeyManagementService.UpdateCryptoKeyPrimaryVersion. */ | |
2674 class UpdateCryptoKeyPrimaryVersionRequest { | |
2675 /** The id of the child CryptoKeyVersion to use as primary. */ | |
2676 core.String cryptoKeyVersionId; | |
2677 | |
2678 UpdateCryptoKeyPrimaryVersionRequest(); | |
2679 | |
2680 UpdateCryptoKeyPrimaryVersionRequest.fromJson(core.Map _json) { | |
2681 if (_json.containsKey("cryptoKeyVersionId")) { | |
2682 cryptoKeyVersionId = _json["cryptoKeyVersionId"]; | |
2683 } | |
2684 } | |
2685 | |
2686 core.Map toJson() { | |
2687 var _json = new core.Map(); | |
2688 if (cryptoKeyVersionId != null) { | |
2689 _json["cryptoKeyVersionId"] = cryptoKeyVersionId; | |
2690 } | |
2691 return _json; | |
2692 } | |
2693 } | |
OLD | NEW |