1#[allow(unused_imports)]
18use super::*;
19
20impl std::fmt::Debug for super::CreateKeyHandleRequest {
21 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
22 let mut debug_struct = f.debug_struct("CreateKeyHandleRequest");
23 debug_struct.field("parent", &self.parent);
24 debug_struct.field("key_handle_id", &self.key_handle_id);
25 debug_struct.field("key_handle", &self.key_handle);
26 if !self._unknown_fields.is_empty() {
27 debug_struct.field("_unknown_fields", &self._unknown_fields);
28 }
29 debug_struct.finish()
30 }
31}
32
33impl std::fmt::Debug for super::GetKeyHandleRequest {
34 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 let mut debug_struct = f.debug_struct("GetKeyHandleRequest");
36 debug_struct.field("name", &self.name);
37 if !self._unknown_fields.is_empty() {
38 debug_struct.field("_unknown_fields", &self._unknown_fields);
39 }
40 debug_struct.finish()
41 }
42}
43
44impl std::fmt::Debug for super::KeyHandle {
45 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46 let mut debug_struct = f.debug_struct("KeyHandle");
47 debug_struct.field("name", &self.name);
48 debug_struct.field("kms_key", &self.kms_key);
49 debug_struct.field("resource_type_selector", &self.resource_type_selector);
50 if !self._unknown_fields.is_empty() {
51 debug_struct.field("_unknown_fields", &self._unknown_fields);
52 }
53 debug_struct.finish()
54 }
55}
56
57impl std::fmt::Debug for super::CreateKeyHandleMetadata {
58 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
59 let mut debug_struct = f.debug_struct("CreateKeyHandleMetadata");
60 if !self._unknown_fields.is_empty() {
61 debug_struct.field("_unknown_fields", &self._unknown_fields);
62 }
63 debug_struct.finish()
64 }
65}
66
67impl std::fmt::Debug for super::ListKeyHandlesRequest {
68 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69 let mut debug_struct = f.debug_struct("ListKeyHandlesRequest");
70 debug_struct.field("parent", &self.parent);
71 debug_struct.field("page_size", &self.page_size);
72 debug_struct.field("page_token", &self.page_token);
73 debug_struct.field("filter", &self.filter);
74 if !self._unknown_fields.is_empty() {
75 debug_struct.field("_unknown_fields", &self._unknown_fields);
76 }
77 debug_struct.finish()
78 }
79}
80
81impl std::fmt::Debug for super::ListKeyHandlesResponse {
82 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
83 let mut debug_struct = f.debug_struct("ListKeyHandlesResponse");
84 debug_struct.field("key_handles", &self.key_handles);
85 debug_struct.field("next_page_token", &self.next_page_token);
86 if !self._unknown_fields.is_empty() {
87 debug_struct.field("_unknown_fields", &self._unknown_fields);
88 }
89 debug_struct.finish()
90 }
91}
92
93impl std::fmt::Debug for super::UpdateAutokeyConfigRequest {
94 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
95 let mut debug_struct = f.debug_struct("UpdateAutokeyConfigRequest");
96 debug_struct.field("autokey_config", &self.autokey_config);
97 debug_struct.field("update_mask", &self.update_mask);
98 if !self._unknown_fields.is_empty() {
99 debug_struct.field("_unknown_fields", &self._unknown_fields);
100 }
101 debug_struct.finish()
102 }
103}
104
105impl std::fmt::Debug for super::GetAutokeyConfigRequest {
106 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
107 let mut debug_struct = f.debug_struct("GetAutokeyConfigRequest");
108 debug_struct.field("name", &self.name);
109 if !self._unknown_fields.is_empty() {
110 debug_struct.field("_unknown_fields", &self._unknown_fields);
111 }
112 debug_struct.finish()
113 }
114}
115
116impl std::fmt::Debug for super::AutokeyConfig {
117 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
118 let mut debug_struct = f.debug_struct("AutokeyConfig");
119 debug_struct.field("name", &self.name);
120 debug_struct.field("key_project", &self.key_project);
121 debug_struct.field("state", &self.state);
122 debug_struct.field("etag", &self.etag);
123 debug_struct.field(
124 "key_project_resolution_mode",
125 &self.key_project_resolution_mode,
126 );
127 if !self._unknown_fields.is_empty() {
128 debug_struct.field("_unknown_fields", &self._unknown_fields);
129 }
130 debug_struct.finish()
131 }
132}
133
134impl std::fmt::Debug for super::ShowEffectiveAutokeyConfigRequest {
135 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
136 let mut debug_struct = f.debug_struct("ShowEffectiveAutokeyConfigRequest");
137 debug_struct.field("parent", &self.parent);
138 if !self._unknown_fields.is_empty() {
139 debug_struct.field("_unknown_fields", &self._unknown_fields);
140 }
141 debug_struct.finish()
142 }
143}
144
145impl std::fmt::Debug for super::ShowEffectiveAutokeyConfigResponse {
146 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
147 let mut debug_struct = f.debug_struct("ShowEffectiveAutokeyConfigResponse");
148 debug_struct.field("key_project", &self.key_project);
149 if !self._unknown_fields.is_empty() {
150 debug_struct.field("_unknown_fields", &self._unknown_fields);
151 }
152 debug_struct.finish()
153 }
154}
155
156impl std::fmt::Debug for super::ListEkmConnectionsRequest {
157 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158 let mut debug_struct = f.debug_struct("ListEkmConnectionsRequest");
159 debug_struct.field("parent", &self.parent);
160 debug_struct.field("page_size", &self.page_size);
161 debug_struct.field("page_token", &self.page_token);
162 debug_struct.field("filter", &self.filter);
163 debug_struct.field("order_by", &self.order_by);
164 if !self._unknown_fields.is_empty() {
165 debug_struct.field("_unknown_fields", &self._unknown_fields);
166 }
167 debug_struct.finish()
168 }
169}
170
171impl std::fmt::Debug for super::ListEkmConnectionsResponse {
172 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
173 let mut debug_struct = f.debug_struct("ListEkmConnectionsResponse");
174 debug_struct.field("ekm_connections", &self.ekm_connections);
175 debug_struct.field("next_page_token", &self.next_page_token);
176 debug_struct.field("total_size", &self.total_size);
177 if !self._unknown_fields.is_empty() {
178 debug_struct.field("_unknown_fields", &self._unknown_fields);
179 }
180 debug_struct.finish()
181 }
182}
183
184impl std::fmt::Debug for super::GetEkmConnectionRequest {
185 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186 let mut debug_struct = f.debug_struct("GetEkmConnectionRequest");
187 debug_struct.field("name", &self.name);
188 if !self._unknown_fields.is_empty() {
189 debug_struct.field("_unknown_fields", &self._unknown_fields);
190 }
191 debug_struct.finish()
192 }
193}
194
195impl std::fmt::Debug for super::CreateEkmConnectionRequest {
196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197 let mut debug_struct = f.debug_struct("CreateEkmConnectionRequest");
198 debug_struct.field("parent", &self.parent);
199 debug_struct.field("ekm_connection_id", &self.ekm_connection_id);
200 debug_struct.field("ekm_connection", &self.ekm_connection);
201 if !self._unknown_fields.is_empty() {
202 debug_struct.field("_unknown_fields", &self._unknown_fields);
203 }
204 debug_struct.finish()
205 }
206}
207
208impl std::fmt::Debug for super::UpdateEkmConnectionRequest {
209 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
210 let mut debug_struct = f.debug_struct("UpdateEkmConnectionRequest");
211 debug_struct.field("ekm_connection", &self.ekm_connection);
212 debug_struct.field("update_mask", &self.update_mask);
213 if !self._unknown_fields.is_empty() {
214 debug_struct.field("_unknown_fields", &self._unknown_fields);
215 }
216 debug_struct.finish()
217 }
218}
219
220impl std::fmt::Debug for super::GetEkmConfigRequest {
221 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
222 let mut debug_struct = f.debug_struct("GetEkmConfigRequest");
223 debug_struct.field("name", &self.name);
224 if !self._unknown_fields.is_empty() {
225 debug_struct.field("_unknown_fields", &self._unknown_fields);
226 }
227 debug_struct.finish()
228 }
229}
230
231impl std::fmt::Debug for super::UpdateEkmConfigRequest {
232 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
233 let mut debug_struct = f.debug_struct("UpdateEkmConfigRequest");
234 debug_struct.field("ekm_config", &self.ekm_config);
235 debug_struct.field("update_mask", &self.update_mask);
236 if !self._unknown_fields.is_empty() {
237 debug_struct.field("_unknown_fields", &self._unknown_fields);
238 }
239 debug_struct.finish()
240 }
241}
242
243impl std::fmt::Debug for super::Certificate {
244 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
245 let mut debug_struct = f.debug_struct("Certificate");
246 debug_struct.field("raw_der", &self.raw_der);
247 debug_struct.field("parsed", &self.parsed);
248 debug_struct.field("issuer", &self.issuer);
249 debug_struct.field("subject", &self.subject);
250 debug_struct.field(
251 "subject_alternative_dns_names",
252 &self.subject_alternative_dns_names,
253 );
254 debug_struct.field("not_before_time", &self.not_before_time);
255 debug_struct.field("not_after_time", &self.not_after_time);
256 debug_struct.field("serial_number", &self.serial_number);
257 debug_struct.field("sha256_fingerprint", &self.sha256_fingerprint);
258 if !self._unknown_fields.is_empty() {
259 debug_struct.field("_unknown_fields", &self._unknown_fields);
260 }
261 debug_struct.finish()
262 }
263}
264
265impl std::fmt::Debug for super::EkmConnection {
266 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
267 let mut debug_struct = f.debug_struct("EkmConnection");
268 debug_struct.field("name", &self.name);
269 debug_struct.field("create_time", &self.create_time);
270 debug_struct.field("service_resolvers", &self.service_resolvers);
271 debug_struct.field("etag", &self.etag);
272 debug_struct.field("key_management_mode", &self.key_management_mode);
273 debug_struct.field("crypto_space_path", &self.crypto_space_path);
274 if !self._unknown_fields.is_empty() {
275 debug_struct.field("_unknown_fields", &self._unknown_fields);
276 }
277 debug_struct.finish()
278 }
279}
280
281impl std::fmt::Debug for super::ekm_connection::ServiceResolver {
282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
283 let mut debug_struct = f.debug_struct("ServiceResolver");
284 debug_struct.field("service_directory_service", &self.service_directory_service);
285 debug_struct.field("endpoint_filter", &self.endpoint_filter);
286 debug_struct.field("hostname", &self.hostname);
287 debug_struct.field("server_certificates", &self.server_certificates);
288 if !self._unknown_fields.is_empty() {
289 debug_struct.field("_unknown_fields", &self._unknown_fields);
290 }
291 debug_struct.finish()
292 }
293}
294
295impl std::fmt::Debug for super::EkmConfig {
296 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
297 let mut debug_struct = f.debug_struct("EkmConfig");
298 debug_struct.field("name", &self.name);
299 debug_struct.field("default_ekm_connection", &self.default_ekm_connection);
300 if !self._unknown_fields.is_empty() {
301 debug_struct.field("_unknown_fields", &self._unknown_fields);
302 }
303 debug_struct.finish()
304 }
305}
306
307impl std::fmt::Debug for super::VerifyConnectivityRequest {
308 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
309 let mut debug_struct = f.debug_struct("VerifyConnectivityRequest");
310 debug_struct.field("name", &self.name);
311 if !self._unknown_fields.is_empty() {
312 debug_struct.field("_unknown_fields", &self._unknown_fields);
313 }
314 debug_struct.finish()
315 }
316}
317
318impl std::fmt::Debug for super::VerifyConnectivityResponse {
319 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
320 let mut debug_struct = f.debug_struct("VerifyConnectivityResponse");
321 if !self._unknown_fields.is_empty() {
322 debug_struct.field("_unknown_fields", &self._unknown_fields);
323 }
324 debug_struct.finish()
325 }
326}
327
328impl std::fmt::Debug for super::SingleTenantHsmInstance {
329 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
330 let mut debug_struct = f.debug_struct("SingleTenantHsmInstance");
331 debug_struct.field("name", &self.name);
332 debug_struct.field("create_time", &self.create_time);
333 debug_struct.field("state", &self.state);
334 debug_struct.field("quorum_auth", &self.quorum_auth);
335 debug_struct.field("delete_time", &self.delete_time);
336 debug_struct.field(
337 "unrefreshed_duration_until_disable",
338 &self.unrefreshed_duration_until_disable,
339 );
340 debug_struct.field("disable_time", &self.disable_time);
341 debug_struct.field("key_portability_enabled", &self.key_portability_enabled);
342 if !self._unknown_fields.is_empty() {
343 debug_struct.field("_unknown_fields", &self._unknown_fields);
344 }
345 debug_struct.finish()
346 }
347}
348
349impl std::fmt::Debug for super::single_tenant_hsm_instance::QuorumAuth {
350 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
351 let mut debug_struct = f.debug_struct("QuorumAuth");
352 debug_struct.field("total_approver_count", &self.total_approver_count);
353 debug_struct.field("required_approver_count", &self.required_approver_count);
354 debug_struct.field(
355 "two_factor_public_key_pems",
356 &self.two_factor_public_key_pems,
357 );
358 if !self._unknown_fields.is_empty() {
359 debug_struct.field("_unknown_fields", &self._unknown_fields);
360 }
361 debug_struct.finish()
362 }
363}
364
365impl std::fmt::Debug for super::SingleTenantHsmInstanceProposal {
366 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
367 let mut debug_struct = f.debug_struct("SingleTenantHsmInstanceProposal");
368 debug_struct.field("name", &self.name);
369 debug_struct.field("create_time", &self.create_time);
370 debug_struct.field("state", &self.state);
371 debug_struct.field("failure_reason", &self.failure_reason);
372 debug_struct.field("delete_time", &self.delete_time);
373 debug_struct.field("purge_time", &self.purge_time);
374 debug_struct.field("approval_parameters", &self.approval_parameters);
375 debug_struct.field("expiration", &self.expiration);
376 debug_struct.field("operation", &self.operation);
377 if !self._unknown_fields.is_empty() {
378 debug_struct.field("_unknown_fields", &self._unknown_fields);
379 }
380 debug_struct.finish()
381 }
382}
383
384impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::QuorumParameters {
385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 let mut debug_struct = f.debug_struct("QuorumParameters");
387 debug_struct.field("required_approver_count", &self.required_approver_count);
388 debug_struct.field("challenges", &self.challenges);
389 debug_struct.field(
390 "approved_two_factor_public_key_pems",
391 &self.approved_two_factor_public_key_pems,
392 );
393 if !self._unknown_fields.is_empty() {
394 debug_struct.field("_unknown_fields", &self._unknown_fields);
395 }
396 debug_struct.finish()
397 }
398}
399
400impl std::fmt::Debug
401 for super::single_tenant_hsm_instance_proposal::RequiredActionQuorumParameters
402{
403 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 let mut debug_struct = f.debug_struct("RequiredActionQuorumParameters");
405 debug_struct.field("required_challenges", &self.required_challenges);
406 debug_struct.field("required_approver_count", &self.required_approver_count);
407 debug_struct.field("quorum_challenges", &self.quorum_challenges);
408 debug_struct.field(
409 "approved_two_factor_public_key_pems",
410 &self.approved_two_factor_public_key_pems,
411 );
412 if !self._unknown_fields.is_empty() {
413 debug_struct.field("_unknown_fields", &self._unknown_fields);
414 }
415 debug_struct.finish()
416 }
417}
418
419impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::RegisterTwoFactorAuthKeys {
420 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
421 let mut debug_struct = f.debug_struct("RegisterTwoFactorAuthKeys");
422 debug_struct.field("required_approver_count", &self.required_approver_count);
423 debug_struct.field(
424 "two_factor_public_key_pems",
425 &self.two_factor_public_key_pems,
426 );
427 if !self._unknown_fields.is_empty() {
428 debug_struct.field("_unknown_fields", &self._unknown_fields);
429 }
430 debug_struct.finish()
431 }
432}
433
434impl std::fmt::Debug
435 for super::single_tenant_hsm_instance_proposal::DisableSingleTenantHsmInstance
436{
437 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
438 let mut debug_struct = f.debug_struct("DisableSingleTenantHsmInstance");
439 if !self._unknown_fields.is_empty() {
440 debug_struct.field("_unknown_fields", &self._unknown_fields);
441 }
442 debug_struct.finish()
443 }
444}
445
446impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::EnableSingleTenantHsmInstance {
447 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
448 let mut debug_struct = f.debug_struct("EnableSingleTenantHsmInstance");
449 if !self._unknown_fields.is_empty() {
450 debug_struct.field("_unknown_fields", &self._unknown_fields);
451 }
452 debug_struct.finish()
453 }
454}
455
456impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::DeleteSingleTenantHsmInstance {
457 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
458 let mut debug_struct = f.debug_struct("DeleteSingleTenantHsmInstance");
459 if !self._unknown_fields.is_empty() {
460 debug_struct.field("_unknown_fields", &self._unknown_fields);
461 }
462 debug_struct.finish()
463 }
464}
465
466impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::AddQuorumMember {
467 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 let mut debug_struct = f.debug_struct("AddQuorumMember");
469 debug_struct.field("two_factor_public_key_pem", &self.two_factor_public_key_pem);
470 if !self._unknown_fields.is_empty() {
471 debug_struct.field("_unknown_fields", &self._unknown_fields);
472 }
473 debug_struct.finish()
474 }
475}
476
477impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::RemoveQuorumMember {
478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
479 let mut debug_struct = f.debug_struct("RemoveQuorumMember");
480 debug_struct.field("two_factor_public_key_pem", &self.two_factor_public_key_pem);
481 if !self._unknown_fields.is_empty() {
482 debug_struct.field("_unknown_fields", &self._unknown_fields);
483 }
484 debug_struct.finish()
485 }
486}
487
488impl std::fmt::Debug
489 for super::single_tenant_hsm_instance_proposal::RefreshSingleTenantHsmInstance
490{
491 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
492 let mut debug_struct = f.debug_struct("RefreshSingleTenantHsmInstance");
493 if !self._unknown_fields.is_empty() {
494 debug_struct.field("_unknown_fields", &self._unknown_fields);
495 }
496 debug_struct.finish()
497 }
498}
499
500impl std::fmt::Debug for super::single_tenant_hsm_instance_proposal::UpgradeKeyTrust {
501 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
502 let mut debug_struct = f.debug_struct("UpgradeKeyTrust");
503 debug_struct.field("name", &self.name);
504 debug_struct.field("two_factor_public_key_pem", &self.two_factor_public_key_pem);
505 if !self._unknown_fields.is_empty() {
506 debug_struct.field("_unknown_fields", &self._unknown_fields);
507 }
508 debug_struct.finish()
509 }
510}
511
512impl std::fmt::Debug for super::Challenge {
513 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
514 let mut debug_struct = f.debug_struct("Challenge");
515 debug_struct.field("challenge", &self.challenge);
516 debug_struct.field("public_key_pem", &self.public_key_pem);
517 if !self._unknown_fields.is_empty() {
518 debug_struct.field("_unknown_fields", &self._unknown_fields);
519 }
520 debug_struct.finish()
521 }
522}
523
524impl std::fmt::Debug for super::ChallengeReply {
525 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
526 let mut debug_struct = f.debug_struct("ChallengeReply");
527 debug_struct.field("signed_challenge", &self.signed_challenge);
528 debug_struct.field("public_key_pem", &self.public_key_pem);
529 if !self._unknown_fields.is_empty() {
530 debug_struct.field("_unknown_fields", &self._unknown_fields);
531 }
532 debug_struct.finish()
533 }
534}
535
536impl std::fmt::Debug for super::ListSingleTenantHsmInstancesRequest {
537 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
538 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstancesRequest");
539 debug_struct.field("parent", &self.parent);
540 debug_struct.field("page_size", &self.page_size);
541 debug_struct.field("page_token", &self.page_token);
542 debug_struct.field("filter", &self.filter);
543 debug_struct.field("order_by", &self.order_by);
544 debug_struct.field("show_deleted", &self.show_deleted);
545 if !self._unknown_fields.is_empty() {
546 debug_struct.field("_unknown_fields", &self._unknown_fields);
547 }
548 debug_struct.finish()
549 }
550}
551
552impl std::fmt::Debug for super::ListSingleTenantHsmInstancesResponse {
553 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
554 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstancesResponse");
555 debug_struct.field(
556 "single_tenant_hsm_instances",
557 &self.single_tenant_hsm_instances,
558 );
559 debug_struct.field("next_page_token", &self.next_page_token);
560 debug_struct.field("total_size", &self.total_size);
561 if !self._unknown_fields.is_empty() {
562 debug_struct.field("_unknown_fields", &self._unknown_fields);
563 }
564 debug_struct.finish()
565 }
566}
567
568impl std::fmt::Debug for super::GetSingleTenantHsmInstanceRequest {
569 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
570 let mut debug_struct = f.debug_struct("GetSingleTenantHsmInstanceRequest");
571 debug_struct.field("name", &self.name);
572 if !self._unknown_fields.is_empty() {
573 debug_struct.field("_unknown_fields", &self._unknown_fields);
574 }
575 debug_struct.finish()
576 }
577}
578
579impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceRequest {
580 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
581 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceRequest");
582 debug_struct.field("parent", &self.parent);
583 debug_struct.field(
584 "single_tenant_hsm_instance_id",
585 &self.single_tenant_hsm_instance_id,
586 );
587 debug_struct.field(
588 "single_tenant_hsm_instance",
589 &self.single_tenant_hsm_instance,
590 );
591 if !self._unknown_fields.is_empty() {
592 debug_struct.field("_unknown_fields", &self._unknown_fields);
593 }
594 debug_struct.finish()
595 }
596}
597
598impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceMetadata {
599 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
600 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceMetadata");
601 if !self._unknown_fields.is_empty() {
602 debug_struct.field("_unknown_fields", &self._unknown_fields);
603 }
604 debug_struct.finish()
605 }
606}
607
608impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceProposalRequest {
609 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
610 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceProposalRequest");
611 debug_struct.field("parent", &self.parent);
612 debug_struct.field(
613 "single_tenant_hsm_instance_proposal_id",
614 &self.single_tenant_hsm_instance_proposal_id,
615 );
616 debug_struct.field(
617 "single_tenant_hsm_instance_proposal",
618 &self.single_tenant_hsm_instance_proposal,
619 );
620 if !self._unknown_fields.is_empty() {
621 debug_struct.field("_unknown_fields", &self._unknown_fields);
622 }
623 debug_struct.finish()
624 }
625}
626
627impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceProposalMetadata {
628 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
629 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceProposalMetadata");
630 if !self._unknown_fields.is_empty() {
631 debug_struct.field("_unknown_fields", &self._unknown_fields);
632 }
633 debug_struct.finish()
634 }
635}
636
637impl std::fmt::Debug for super::GetSingleTenantHsmInstanceProposalRequest {
638 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
639 let mut debug_struct = f.debug_struct("GetSingleTenantHsmInstanceProposalRequest");
640 debug_struct.field("name", &self.name);
641 if !self._unknown_fields.is_empty() {
642 debug_struct.field("_unknown_fields", &self._unknown_fields);
643 }
644 debug_struct.finish()
645 }
646}
647
648impl std::fmt::Debug for super::ApproveSingleTenantHsmInstanceProposalRequest {
649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
650 let mut debug_struct = f.debug_struct("ApproveSingleTenantHsmInstanceProposalRequest");
651 debug_struct.field("name", &self.name);
652 debug_struct.field("approval_payload", &self.approval_payload);
653 if !self._unknown_fields.is_empty() {
654 debug_struct.field("_unknown_fields", &self._unknown_fields);
655 }
656 debug_struct.finish()
657 }
658}
659
660impl std::fmt::Debug for super::approve_single_tenant_hsm_instance_proposal_request::QuorumReply {
661 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
662 let mut debug_struct = f.debug_struct("QuorumReply");
663 debug_struct.field("challenge_replies", &self.challenge_replies);
664 if !self._unknown_fields.is_empty() {
665 debug_struct.field("_unknown_fields", &self._unknown_fields);
666 }
667 debug_struct.finish()
668 }
669}
670
671impl std::fmt::Debug
672 for super::approve_single_tenant_hsm_instance_proposal_request::RequiredActionQuorumReply
673{
674 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
675 let mut debug_struct = f.debug_struct("RequiredActionQuorumReply");
676 debug_struct.field(
677 "required_challenge_replies",
678 &self.required_challenge_replies,
679 );
680 debug_struct.field("quorum_challenge_replies", &self.quorum_challenge_replies);
681 if !self._unknown_fields.is_empty() {
682 debug_struct.field("_unknown_fields", &self._unknown_fields);
683 }
684 debug_struct.finish()
685 }
686}
687
688impl std::fmt::Debug for super::ApproveSingleTenantHsmInstanceProposalResponse {
689 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
690 let mut debug_struct = f.debug_struct("ApproveSingleTenantHsmInstanceProposalResponse");
691 if !self._unknown_fields.is_empty() {
692 debug_struct.field("_unknown_fields", &self._unknown_fields);
693 }
694 debug_struct.finish()
695 }
696}
697
698impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalRequest {
699 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
700 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalRequest");
701 debug_struct.field("name", &self.name);
702 if !self._unknown_fields.is_empty() {
703 debug_struct.field("_unknown_fields", &self._unknown_fields);
704 }
705 debug_struct.finish()
706 }
707}
708
709impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalResponse {
710 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
711 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalResponse");
712 if !self._unknown_fields.is_empty() {
713 debug_struct.field("_unknown_fields", &self._unknown_fields);
714 }
715 debug_struct.finish()
716 }
717}
718
719impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalMetadata {
720 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
721 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalMetadata");
722 if !self._unknown_fields.is_empty() {
723 debug_struct.field("_unknown_fields", &self._unknown_fields);
724 }
725 debug_struct.finish()
726 }
727}
728
729impl std::fmt::Debug for super::ListSingleTenantHsmInstanceProposalsRequest {
730 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
731 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstanceProposalsRequest");
732 debug_struct.field("parent", &self.parent);
733 debug_struct.field("page_size", &self.page_size);
734 debug_struct.field("page_token", &self.page_token);
735 debug_struct.field("filter", &self.filter);
736 debug_struct.field("order_by", &self.order_by);
737 debug_struct.field("show_deleted", &self.show_deleted);
738 if !self._unknown_fields.is_empty() {
739 debug_struct.field("_unknown_fields", &self._unknown_fields);
740 }
741 debug_struct.finish()
742 }
743}
744
745impl std::fmt::Debug for super::ListSingleTenantHsmInstanceProposalsResponse {
746 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
747 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstanceProposalsResponse");
748 debug_struct.field(
749 "single_tenant_hsm_instance_proposals",
750 &self.single_tenant_hsm_instance_proposals,
751 );
752 debug_struct.field("next_page_token", &self.next_page_token);
753 debug_struct.field("total_size", &self.total_size);
754 if !self._unknown_fields.is_empty() {
755 debug_struct.field("_unknown_fields", &self._unknown_fields);
756 }
757 debug_struct.finish()
758 }
759}
760
761impl std::fmt::Debug for super::DeleteSingleTenantHsmInstanceProposalRequest {
762 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
763 let mut debug_struct = f.debug_struct("DeleteSingleTenantHsmInstanceProposalRequest");
764 debug_struct.field("name", &self.name);
765 if !self._unknown_fields.is_empty() {
766 debug_struct.field("_unknown_fields", &self._unknown_fields);
767 }
768 debug_struct.finish()
769 }
770}
771
772impl std::fmt::Debug for super::KeyRing {
773 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774 let mut debug_struct = f.debug_struct("KeyRing");
775 debug_struct.field("name", &self.name);
776 debug_struct.field("create_time", &self.create_time);
777 if !self._unknown_fields.is_empty() {
778 debug_struct.field("_unknown_fields", &self._unknown_fields);
779 }
780 debug_struct.finish()
781 }
782}
783
784impl std::fmt::Debug for super::CryptoKey {
785 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
786 let mut debug_struct = f.debug_struct("CryptoKey");
787 debug_struct.field("name", &self.name);
788 debug_struct.field("primary", &self.primary);
789 debug_struct.field("purpose", &self.purpose);
790 debug_struct.field("create_time", &self.create_time);
791 debug_struct.field("next_rotation_time", &self.next_rotation_time);
792 debug_struct.field("version_template", &self.version_template);
793 debug_struct.field("labels", &self.labels);
794 debug_struct.field("import_only", &self.import_only);
795 debug_struct.field(
796 "destroy_scheduled_duration",
797 &self.destroy_scheduled_duration,
798 );
799 debug_struct.field("crypto_key_backend", &self.crypto_key_backend);
800 debug_struct.field(
801 "key_access_justifications_policy",
802 &self.key_access_justifications_policy,
803 );
804 debug_struct.field("rotation_schedule", &self.rotation_schedule);
805 if !self._unknown_fields.is_empty() {
806 debug_struct.field("_unknown_fields", &self._unknown_fields);
807 }
808 debug_struct.finish()
809 }
810}
811
812impl std::fmt::Debug for super::CryptoKeyVersionTemplate {
813 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
814 let mut debug_struct = f.debug_struct("CryptoKeyVersionTemplate");
815 debug_struct.field("protection_level", &self.protection_level);
816 debug_struct.field("algorithm", &self.algorithm);
817 if !self._unknown_fields.is_empty() {
818 debug_struct.field("_unknown_fields", &self._unknown_fields);
819 }
820 debug_struct.finish()
821 }
822}
823
824impl std::fmt::Debug for super::KeyOperationAttestation {
825 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
826 let mut debug_struct = f.debug_struct("KeyOperationAttestation");
827 debug_struct.field("format", &self.format);
828 debug_struct.field("content", &self.content);
829 debug_struct.field("cert_chains", &self.cert_chains);
830 if !self._unknown_fields.is_empty() {
831 debug_struct.field("_unknown_fields", &self._unknown_fields);
832 }
833 debug_struct.finish()
834 }
835}
836
837impl std::fmt::Debug for super::key_operation_attestation::CertificateChains {
838 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
839 let mut debug_struct = f.debug_struct("CertificateChains");
840 debug_struct.field("cavium_certs", &self.cavium_certs);
841 debug_struct.field("google_card_certs", &self.google_card_certs);
842 debug_struct.field("google_partition_certs", &self.google_partition_certs);
843 if !self._unknown_fields.is_empty() {
844 debug_struct.field("_unknown_fields", &self._unknown_fields);
845 }
846 debug_struct.finish()
847 }
848}
849
850impl std::fmt::Debug for super::CryptoKeyVersion {
851 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
852 let mut debug_struct = f.debug_struct("CryptoKeyVersion");
853 debug_struct.field("name", &self.name);
854 debug_struct.field("state", &self.state);
855 debug_struct.field("protection_level", &self.protection_level);
856 debug_struct.field("algorithm", &self.algorithm);
857 debug_struct.field("attestation", &self.attestation);
858 debug_struct.field("create_time", &self.create_time);
859 debug_struct.field("generate_time", &self.generate_time);
860 debug_struct.field("destroy_time", &self.destroy_time);
861 debug_struct.field("destroy_event_time", &self.destroy_event_time);
862 debug_struct.field("import_job", &self.import_job);
863 debug_struct.field("import_time", &self.import_time);
864 debug_struct.field("import_failure_reason", &self.import_failure_reason);
865 debug_struct.field("generation_failure_reason", &self.generation_failure_reason);
866 debug_struct.field(
867 "external_destruction_failure_reason",
868 &self.external_destruction_failure_reason,
869 );
870 debug_struct.field(
871 "external_protection_level_options",
872 &self.external_protection_level_options,
873 );
874 debug_struct.field("reimport_eligible", &self.reimport_eligible);
875 debug_struct.field("trusted_wrapping_enabled", &self.trusted_wrapping_enabled);
876 debug_struct.field("hsm_trusted", &self.hsm_trusted);
877 if !self._unknown_fields.is_empty() {
878 debug_struct.field("_unknown_fields", &self._unknown_fields);
879 }
880 debug_struct.finish()
881 }
882}
883
884impl std::fmt::Debug for super::ChecksummedData {
885 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
886 let mut debug_struct = f.debug_struct("ChecksummedData");
887 debug_struct.field("data", &self.data);
888 debug_struct.field("crc32c_checksum", &self.crc32c_checksum);
889 if !self._unknown_fields.is_empty() {
890 debug_struct.field("_unknown_fields", &self._unknown_fields);
891 }
892 debug_struct.finish()
893 }
894}
895
896impl std::fmt::Debug for super::PublicKey {
897 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
898 let mut debug_struct = f.debug_struct("PublicKey");
899 debug_struct.field("pem", &self.pem);
900 debug_struct.field("algorithm", &self.algorithm);
901 debug_struct.field("pem_crc32c", &self.pem_crc32c);
902 debug_struct.field("name", &self.name);
903 debug_struct.field("protection_level", &self.protection_level);
904 debug_struct.field("public_key_format", &self.public_key_format);
905 debug_struct.field("public_key", &self.public_key);
906 if !self._unknown_fields.is_empty() {
907 debug_struct.field("_unknown_fields", &self._unknown_fields);
908 }
909 debug_struct.finish()
910 }
911}
912
913impl std::fmt::Debug for super::ImportJob {
914 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
915 let mut debug_struct = f.debug_struct("ImportJob");
916 debug_struct.field("name", &self.name);
917 debug_struct.field("import_method", &self.import_method);
918 debug_struct.field("protection_level", &self.protection_level);
919 debug_struct.field("create_time", &self.create_time);
920 debug_struct.field("generate_time", &self.generate_time);
921 debug_struct.field("expire_time", &self.expire_time);
922 debug_struct.field("expire_event_time", &self.expire_event_time);
923 debug_struct.field("state", &self.state);
924 debug_struct.field("public_key", &self.public_key);
925 debug_struct.field("public_key_format", &self.public_key_format);
926 debug_struct.field("attestation", &self.attestation);
927 debug_struct.field("crypto_key_backend", &self.crypto_key_backend);
928 if !self._unknown_fields.is_empty() {
929 debug_struct.field("_unknown_fields", &self._unknown_fields);
930 }
931 debug_struct.finish()
932 }
933}
934
935impl std::fmt::Debug for super::import_job::WrappingPublicKey {
936 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
937 let mut debug_struct = f.debug_struct("WrappingPublicKey");
938 debug_struct.field("pem", &self.pem);
939 debug_struct.field("data", &self.data);
940 if !self._unknown_fields.is_empty() {
941 debug_struct.field("_unknown_fields", &self._unknown_fields);
942 }
943 debug_struct.finish()
944 }
945}
946
947impl std::fmt::Debug for super::ExternalProtectionLevelOptions {
948 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
949 let mut debug_struct = f.debug_struct("ExternalProtectionLevelOptions");
950 debug_struct.field("external_key_uri", &self.external_key_uri);
951 debug_struct.field("ekm_connection_key_path", &self.ekm_connection_key_path);
952 if !self._unknown_fields.is_empty() {
953 debug_struct.field("_unknown_fields", &self._unknown_fields);
954 }
955 debug_struct.finish()
956 }
957}
958
959impl std::fmt::Debug for super::KeyAccessJustificationsPolicy {
960 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
961 let mut debug_struct = f.debug_struct("KeyAccessJustificationsPolicy");
962 debug_struct.field("allowed_access_reasons", &self.allowed_access_reasons);
963 if !self._unknown_fields.is_empty() {
964 debug_struct.field("_unknown_fields", &self._unknown_fields);
965 }
966 debug_struct.finish()
967 }
968}
969
970impl std::fmt::Debug for super::RetiredResource {
971 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
972 let mut debug_struct = f.debug_struct("RetiredResource");
973 debug_struct.field("name", &self.name);
974 debug_struct.field("original_resource", &self.original_resource);
975 debug_struct.field("resource_type", &self.resource_type);
976 debug_struct.field("delete_time", &self.delete_time);
977 if !self._unknown_fields.is_empty() {
978 debug_struct.field("_unknown_fields", &self._unknown_fields);
979 }
980 debug_struct.finish()
981 }
982}
983
984impl std::fmt::Debug for super::ListKeyRingsRequest {
985 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
986 let mut debug_struct = f.debug_struct("ListKeyRingsRequest");
987 debug_struct.field("parent", &self.parent);
988 debug_struct.field("page_size", &self.page_size);
989 debug_struct.field("page_token", &self.page_token);
990 debug_struct.field("filter", &self.filter);
991 debug_struct.field("order_by", &self.order_by);
992 if !self._unknown_fields.is_empty() {
993 debug_struct.field("_unknown_fields", &self._unknown_fields);
994 }
995 debug_struct.finish()
996 }
997}
998
999impl std::fmt::Debug for super::ListCryptoKeysRequest {
1000 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1001 let mut debug_struct = f.debug_struct("ListCryptoKeysRequest");
1002 debug_struct.field("parent", &self.parent);
1003 debug_struct.field("page_size", &self.page_size);
1004 debug_struct.field("page_token", &self.page_token);
1005 debug_struct.field("version_view", &self.version_view);
1006 debug_struct.field("filter", &self.filter);
1007 debug_struct.field("order_by", &self.order_by);
1008 if !self._unknown_fields.is_empty() {
1009 debug_struct.field("_unknown_fields", &self._unknown_fields);
1010 }
1011 debug_struct.finish()
1012 }
1013}
1014
1015impl std::fmt::Debug for super::ListCryptoKeyVersionsRequest {
1016 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1017 let mut debug_struct = f.debug_struct("ListCryptoKeyVersionsRequest");
1018 debug_struct.field("parent", &self.parent);
1019 debug_struct.field("page_size", &self.page_size);
1020 debug_struct.field("page_token", &self.page_token);
1021 debug_struct.field("view", &self.view);
1022 debug_struct.field("filter", &self.filter);
1023 debug_struct.field("order_by", &self.order_by);
1024 if !self._unknown_fields.is_empty() {
1025 debug_struct.field("_unknown_fields", &self._unknown_fields);
1026 }
1027 debug_struct.finish()
1028 }
1029}
1030
1031impl std::fmt::Debug for super::ListImportJobsRequest {
1032 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1033 let mut debug_struct = f.debug_struct("ListImportJobsRequest");
1034 debug_struct.field("parent", &self.parent);
1035 debug_struct.field("page_size", &self.page_size);
1036 debug_struct.field("page_token", &self.page_token);
1037 debug_struct.field("filter", &self.filter);
1038 debug_struct.field("order_by", &self.order_by);
1039 if !self._unknown_fields.is_empty() {
1040 debug_struct.field("_unknown_fields", &self._unknown_fields);
1041 }
1042 debug_struct.finish()
1043 }
1044}
1045
1046impl std::fmt::Debug for super::ListRetiredResourcesRequest {
1047 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1048 let mut debug_struct = f.debug_struct("ListRetiredResourcesRequest");
1049 debug_struct.field("parent", &self.parent);
1050 debug_struct.field("page_size", &self.page_size);
1051 debug_struct.field("page_token", &self.page_token);
1052 if !self._unknown_fields.is_empty() {
1053 debug_struct.field("_unknown_fields", &self._unknown_fields);
1054 }
1055 debug_struct.finish()
1056 }
1057}
1058
1059impl std::fmt::Debug for super::ListKeyRingsResponse {
1060 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1061 let mut debug_struct = f.debug_struct("ListKeyRingsResponse");
1062 debug_struct.field("key_rings", &self.key_rings);
1063 debug_struct.field("next_page_token", &self.next_page_token);
1064 debug_struct.field("total_size", &self.total_size);
1065 if !self._unknown_fields.is_empty() {
1066 debug_struct.field("_unknown_fields", &self._unknown_fields);
1067 }
1068 debug_struct.finish()
1069 }
1070}
1071
1072impl std::fmt::Debug for super::ListCryptoKeysResponse {
1073 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1074 let mut debug_struct = f.debug_struct("ListCryptoKeysResponse");
1075 debug_struct.field("crypto_keys", &self.crypto_keys);
1076 debug_struct.field("next_page_token", &self.next_page_token);
1077 debug_struct.field("total_size", &self.total_size);
1078 if !self._unknown_fields.is_empty() {
1079 debug_struct.field("_unknown_fields", &self._unknown_fields);
1080 }
1081 debug_struct.finish()
1082 }
1083}
1084
1085impl std::fmt::Debug for super::ListCryptoKeyVersionsResponse {
1086 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1087 let mut debug_struct = f.debug_struct("ListCryptoKeyVersionsResponse");
1088 debug_struct.field("crypto_key_versions", &self.crypto_key_versions);
1089 debug_struct.field("next_page_token", &self.next_page_token);
1090 debug_struct.field("total_size", &self.total_size);
1091 if !self._unknown_fields.is_empty() {
1092 debug_struct.field("_unknown_fields", &self._unknown_fields);
1093 }
1094 debug_struct.finish()
1095 }
1096}
1097
1098impl std::fmt::Debug for super::ListImportJobsResponse {
1099 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1100 let mut debug_struct = f.debug_struct("ListImportJobsResponse");
1101 debug_struct.field("import_jobs", &self.import_jobs);
1102 debug_struct.field("next_page_token", &self.next_page_token);
1103 debug_struct.field("total_size", &self.total_size);
1104 if !self._unknown_fields.is_empty() {
1105 debug_struct.field("_unknown_fields", &self._unknown_fields);
1106 }
1107 debug_struct.finish()
1108 }
1109}
1110
1111impl std::fmt::Debug for super::ListRetiredResourcesResponse {
1112 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1113 let mut debug_struct = f.debug_struct("ListRetiredResourcesResponse");
1114 debug_struct.field("retired_resources", &self.retired_resources);
1115 debug_struct.field("next_page_token", &self.next_page_token);
1116 debug_struct.field("total_size", &self.total_size);
1117 if !self._unknown_fields.is_empty() {
1118 debug_struct.field("_unknown_fields", &self._unknown_fields);
1119 }
1120 debug_struct.finish()
1121 }
1122}
1123
1124impl std::fmt::Debug for super::GetKeyRingRequest {
1125 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1126 let mut debug_struct = f.debug_struct("GetKeyRingRequest");
1127 debug_struct.field("name", &self.name);
1128 if !self._unknown_fields.is_empty() {
1129 debug_struct.field("_unknown_fields", &self._unknown_fields);
1130 }
1131 debug_struct.finish()
1132 }
1133}
1134
1135impl std::fmt::Debug for super::GetCryptoKeyRequest {
1136 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1137 let mut debug_struct = f.debug_struct("GetCryptoKeyRequest");
1138 debug_struct.field("name", &self.name);
1139 if !self._unknown_fields.is_empty() {
1140 debug_struct.field("_unknown_fields", &self._unknown_fields);
1141 }
1142 debug_struct.finish()
1143 }
1144}
1145
1146impl std::fmt::Debug for super::GetCryptoKeyVersionRequest {
1147 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1148 let mut debug_struct = f.debug_struct("GetCryptoKeyVersionRequest");
1149 debug_struct.field("name", &self.name);
1150 if !self._unknown_fields.is_empty() {
1151 debug_struct.field("_unknown_fields", &self._unknown_fields);
1152 }
1153 debug_struct.finish()
1154 }
1155}
1156
1157impl std::fmt::Debug for super::GetPublicKeyRequest {
1158 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1159 let mut debug_struct = f.debug_struct("GetPublicKeyRequest");
1160 debug_struct.field("name", &self.name);
1161 debug_struct.field("public_key_format", &self.public_key_format);
1162 if !self._unknown_fields.is_empty() {
1163 debug_struct.field("_unknown_fields", &self._unknown_fields);
1164 }
1165 debug_struct.finish()
1166 }
1167}
1168
1169impl std::fmt::Debug for super::GetImportJobRequest {
1170 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1171 let mut debug_struct = f.debug_struct("GetImportJobRequest");
1172 debug_struct.field("name", &self.name);
1173 debug_struct.field("public_key_format", &self.public_key_format);
1174 if !self._unknown_fields.is_empty() {
1175 debug_struct.field("_unknown_fields", &self._unknown_fields);
1176 }
1177 debug_struct.finish()
1178 }
1179}
1180
1181impl std::fmt::Debug for super::GetRetiredResourceRequest {
1182 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1183 let mut debug_struct = f.debug_struct("GetRetiredResourceRequest");
1184 debug_struct.field("name", &self.name);
1185 if !self._unknown_fields.is_empty() {
1186 debug_struct.field("_unknown_fields", &self._unknown_fields);
1187 }
1188 debug_struct.finish()
1189 }
1190}
1191
1192impl std::fmt::Debug for super::CreateKeyRingRequest {
1193 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1194 let mut debug_struct = f.debug_struct("CreateKeyRingRequest");
1195 debug_struct.field("parent", &self.parent);
1196 debug_struct.field("key_ring_id", &self.key_ring_id);
1197 debug_struct.field("key_ring", &self.key_ring);
1198 if !self._unknown_fields.is_empty() {
1199 debug_struct.field("_unknown_fields", &self._unknown_fields);
1200 }
1201 debug_struct.finish()
1202 }
1203}
1204
1205impl std::fmt::Debug for super::CreateCryptoKeyRequest {
1206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1207 let mut debug_struct = f.debug_struct("CreateCryptoKeyRequest");
1208 debug_struct.field("parent", &self.parent);
1209 debug_struct.field("crypto_key_id", &self.crypto_key_id);
1210 debug_struct.field("crypto_key", &self.crypto_key);
1211 debug_struct.field(
1212 "skip_initial_version_creation",
1213 &self.skip_initial_version_creation,
1214 );
1215 debug_struct.field("trusted_wrapping_enabled", &self.trusted_wrapping_enabled);
1216 if !self._unknown_fields.is_empty() {
1217 debug_struct.field("_unknown_fields", &self._unknown_fields);
1218 }
1219 debug_struct.finish()
1220 }
1221}
1222
1223impl std::fmt::Debug for super::CreateCryptoKeyVersionRequest {
1224 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1225 let mut debug_struct = f.debug_struct("CreateCryptoKeyVersionRequest");
1226 debug_struct.field("parent", &self.parent);
1227 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1228 if !self._unknown_fields.is_empty() {
1229 debug_struct.field("_unknown_fields", &self._unknown_fields);
1230 }
1231 debug_struct.finish()
1232 }
1233}
1234
1235impl std::fmt::Debug for super::DeleteCryptoKeyRequest {
1236 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1237 let mut debug_struct = f.debug_struct("DeleteCryptoKeyRequest");
1238 debug_struct.field("name", &self.name);
1239 if !self._unknown_fields.is_empty() {
1240 debug_struct.field("_unknown_fields", &self._unknown_fields);
1241 }
1242 debug_struct.finish()
1243 }
1244}
1245
1246impl std::fmt::Debug for super::DeleteCryptoKeyVersionRequest {
1247 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1248 let mut debug_struct = f.debug_struct("DeleteCryptoKeyVersionRequest");
1249 debug_struct.field("name", &self.name);
1250 if !self._unknown_fields.is_empty() {
1251 debug_struct.field("_unknown_fields", &self._unknown_fields);
1252 }
1253 debug_struct.finish()
1254 }
1255}
1256
1257impl std::fmt::Debug for super::ImportCryptoKeyVersionRequest {
1258 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1259 let mut debug_struct = f.debug_struct("ImportCryptoKeyVersionRequest");
1260 debug_struct.field("parent", &self.parent);
1261 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1262 debug_struct.field("algorithm", &self.algorithm);
1263 debug_struct.field("import_job", &self.import_job);
1264 debug_struct.field("wrapped_key", &self.wrapped_key);
1265 debug_struct.field("trusted_wrapping_enabled", &self.trusted_wrapping_enabled);
1266 debug_struct.field("wrapped_key_material", &self.wrapped_key_material);
1267 if !self._unknown_fields.is_empty() {
1268 debug_struct.field("_unknown_fields", &self._unknown_fields);
1269 }
1270 debug_struct.finish()
1271 }
1272}
1273
1274impl std::fmt::Debug for super::ImportTrustedKeyWrappedCryptoKeyVersionRequest {
1275 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1276 let mut debug_struct = f.debug_struct("ImportTrustedKeyWrappedCryptoKeyVersionRequest");
1277 debug_struct.field("parent", &self.parent);
1278 debug_struct.field("importing_key", &self.importing_key);
1279 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1280 debug_struct.field("wrapped_key", &self.wrapped_key);
1281 debug_struct.field("algorithm", &self.algorithm);
1282 if !self._unknown_fields.is_empty() {
1283 debug_struct.field("_unknown_fields", &self._unknown_fields);
1284 }
1285 debug_struct.finish()
1286 }
1287}
1288
1289impl std::fmt::Debug for super::ExportTrustedKeyWrappedCryptoKeyVersionRequest {
1290 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1291 let mut debug_struct = f.debug_struct("ExportTrustedKeyWrappedCryptoKeyVersionRequest");
1292 debug_struct.field("name", &self.name);
1293 debug_struct.field("wrapping_key", &self.wrapping_key);
1294 if !self._unknown_fields.is_empty() {
1295 debug_struct.field("_unknown_fields", &self._unknown_fields);
1296 }
1297 debug_struct.finish()
1298 }
1299}
1300
1301impl std::fmt::Debug for super::ExportTrustedKeyWrappedCryptoKeyVersionResponse {
1302 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1303 let mut debug_struct = f.debug_struct("ExportTrustedKeyWrappedCryptoKeyVersionResponse");
1304 debug_struct.field("wrapped_key", &self.wrapped_key);
1305 debug_struct.field("wrapped_key_crc32c", &self.wrapped_key_crc32c);
1306 if !self._unknown_fields.is_empty() {
1307 debug_struct.field("_unknown_fields", &self._unknown_fields);
1308 }
1309 debug_struct.finish()
1310 }
1311}
1312
1313impl std::fmt::Debug for super::CreateImportJobRequest {
1314 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 let mut debug_struct = f.debug_struct("CreateImportJobRequest");
1316 debug_struct.field("parent", &self.parent);
1317 debug_struct.field("import_job_id", &self.import_job_id);
1318 debug_struct.field("import_job", &self.import_job);
1319 if !self._unknown_fields.is_empty() {
1320 debug_struct.field("_unknown_fields", &self._unknown_fields);
1321 }
1322 debug_struct.finish()
1323 }
1324}
1325
1326impl std::fmt::Debug for super::UpdateCryptoKeyRequest {
1327 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1328 let mut debug_struct = f.debug_struct("UpdateCryptoKeyRequest");
1329 debug_struct.field("crypto_key", &self.crypto_key);
1330 debug_struct.field("update_mask", &self.update_mask);
1331 if !self._unknown_fields.is_empty() {
1332 debug_struct.field("_unknown_fields", &self._unknown_fields);
1333 }
1334 debug_struct.finish()
1335 }
1336}
1337
1338impl std::fmt::Debug for super::UpdateCryptoKeyVersionRequest {
1339 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1340 let mut debug_struct = f.debug_struct("UpdateCryptoKeyVersionRequest");
1341 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1342 debug_struct.field("update_mask", &self.update_mask);
1343 if !self._unknown_fields.is_empty() {
1344 debug_struct.field("_unknown_fields", &self._unknown_fields);
1345 }
1346 debug_struct.finish()
1347 }
1348}
1349
1350impl std::fmt::Debug for super::UpdateCryptoKeyPrimaryVersionRequest {
1351 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1352 let mut debug_struct = f.debug_struct("UpdateCryptoKeyPrimaryVersionRequest");
1353 debug_struct.field("name", &self.name);
1354 debug_struct.field("crypto_key_version_id", &self.crypto_key_version_id);
1355 if !self._unknown_fields.is_empty() {
1356 debug_struct.field("_unknown_fields", &self._unknown_fields);
1357 }
1358 debug_struct.finish()
1359 }
1360}
1361
1362impl std::fmt::Debug for super::DestroyCryptoKeyVersionRequest {
1363 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1364 let mut debug_struct = f.debug_struct("DestroyCryptoKeyVersionRequest");
1365 debug_struct.field("name", &self.name);
1366 if !self._unknown_fields.is_empty() {
1367 debug_struct.field("_unknown_fields", &self._unknown_fields);
1368 }
1369 debug_struct.finish()
1370 }
1371}
1372
1373impl std::fmt::Debug for super::RestoreCryptoKeyVersionRequest {
1374 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375 let mut debug_struct = f.debug_struct("RestoreCryptoKeyVersionRequest");
1376 debug_struct.field("name", &self.name);
1377 if !self._unknown_fields.is_empty() {
1378 debug_struct.field("_unknown_fields", &self._unknown_fields);
1379 }
1380 debug_struct.finish()
1381 }
1382}
1383
1384impl std::fmt::Debug for super::EncryptRequest {
1385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1386 let mut debug_struct = f.debug_struct("EncryptRequest");
1387 debug_struct.field("name", &self.name);
1388 debug_struct.field("plaintext", &self.plaintext);
1389 debug_struct.field(
1390 "additional_authenticated_data",
1391 &self.additional_authenticated_data,
1392 );
1393 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1394 debug_struct.field(
1395 "additional_authenticated_data_crc32c",
1396 &self.additional_authenticated_data_crc32c,
1397 );
1398 if !self._unknown_fields.is_empty() {
1399 debug_struct.field("_unknown_fields", &self._unknown_fields);
1400 }
1401 debug_struct.finish()
1402 }
1403}
1404
1405impl std::fmt::Debug for super::DecryptRequest {
1406 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1407 let mut debug_struct = f.debug_struct("DecryptRequest");
1408 debug_struct.field("name", &self.name);
1409 debug_struct.field("ciphertext", &self.ciphertext);
1410 debug_struct.field(
1411 "additional_authenticated_data",
1412 &self.additional_authenticated_data,
1413 );
1414 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1415 debug_struct.field(
1416 "additional_authenticated_data_crc32c",
1417 &self.additional_authenticated_data_crc32c,
1418 );
1419 if !self._unknown_fields.is_empty() {
1420 debug_struct.field("_unknown_fields", &self._unknown_fields);
1421 }
1422 debug_struct.finish()
1423 }
1424}
1425
1426impl std::fmt::Debug for super::RawEncryptRequest {
1427 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1428 let mut debug_struct = f.debug_struct("RawEncryptRequest");
1429 debug_struct.field("name", &self.name);
1430 debug_struct.field("plaintext", &self.plaintext);
1431 debug_struct.field(
1432 "additional_authenticated_data",
1433 &self.additional_authenticated_data,
1434 );
1435 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1436 debug_struct.field(
1437 "additional_authenticated_data_crc32c",
1438 &self.additional_authenticated_data_crc32c,
1439 );
1440 debug_struct.field("initialization_vector", &self.initialization_vector);
1441 debug_struct.field(
1442 "initialization_vector_crc32c",
1443 &self.initialization_vector_crc32c,
1444 );
1445 if !self._unknown_fields.is_empty() {
1446 debug_struct.field("_unknown_fields", &self._unknown_fields);
1447 }
1448 debug_struct.finish()
1449 }
1450}
1451
1452impl std::fmt::Debug for super::RawDecryptRequest {
1453 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1454 let mut debug_struct = f.debug_struct("RawDecryptRequest");
1455 debug_struct.field("name", &self.name);
1456 debug_struct.field("ciphertext", &self.ciphertext);
1457 debug_struct.field(
1458 "additional_authenticated_data",
1459 &self.additional_authenticated_data,
1460 );
1461 debug_struct.field("initialization_vector", &self.initialization_vector);
1462 debug_struct.field("tag_length", &self.tag_length);
1463 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1464 debug_struct.field(
1465 "additional_authenticated_data_crc32c",
1466 &self.additional_authenticated_data_crc32c,
1467 );
1468 debug_struct.field(
1469 "initialization_vector_crc32c",
1470 &self.initialization_vector_crc32c,
1471 );
1472 if !self._unknown_fields.is_empty() {
1473 debug_struct.field("_unknown_fields", &self._unknown_fields);
1474 }
1475 debug_struct.finish()
1476 }
1477}
1478
1479impl std::fmt::Debug for super::AsymmetricSignRequest {
1480 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1481 let mut debug_struct = f.debug_struct("AsymmetricSignRequest");
1482 debug_struct.field("name", &self.name);
1483 debug_struct.field("digest", &self.digest);
1484 debug_struct.field("digest_crc32c", &self.digest_crc32c);
1485 debug_struct.field("data", &self.data);
1486 debug_struct.field("data_crc32c", &self.data_crc32c);
1487 if !self._unknown_fields.is_empty() {
1488 debug_struct.field("_unknown_fields", &self._unknown_fields);
1489 }
1490 debug_struct.finish()
1491 }
1492}
1493
1494impl std::fmt::Debug for super::AsymmetricDecryptRequest {
1495 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1496 let mut debug_struct = f.debug_struct("AsymmetricDecryptRequest");
1497 debug_struct.field("name", &self.name);
1498 debug_struct.field("ciphertext", &self.ciphertext);
1499 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1500 if !self._unknown_fields.is_empty() {
1501 debug_struct.field("_unknown_fields", &self._unknown_fields);
1502 }
1503 debug_struct.finish()
1504 }
1505}
1506
1507impl std::fmt::Debug for super::MacSignRequest {
1508 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1509 let mut debug_struct = f.debug_struct("MacSignRequest");
1510 debug_struct.field("name", &self.name);
1511 debug_struct.field("data", &self.data);
1512 debug_struct.field("data_crc32c", &self.data_crc32c);
1513 if !self._unknown_fields.is_empty() {
1514 debug_struct.field("_unknown_fields", &self._unknown_fields);
1515 }
1516 debug_struct.finish()
1517 }
1518}
1519
1520impl std::fmt::Debug for super::MacVerifyRequest {
1521 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1522 let mut debug_struct = f.debug_struct("MacVerifyRequest");
1523 debug_struct.field("name", &self.name);
1524 debug_struct.field("data", &self.data);
1525 debug_struct.field("data_crc32c", &self.data_crc32c);
1526 debug_struct.field("mac", &self.mac);
1527 debug_struct.field("mac_crc32c", &self.mac_crc32c);
1528 if !self._unknown_fields.is_empty() {
1529 debug_struct.field("_unknown_fields", &self._unknown_fields);
1530 }
1531 debug_struct.finish()
1532 }
1533}
1534
1535impl std::fmt::Debug for super::DecapsulateRequest {
1536 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1537 let mut debug_struct = f.debug_struct("DecapsulateRequest");
1538 debug_struct.field("name", &self.name);
1539 debug_struct.field("ciphertext", &self.ciphertext);
1540 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1541 if !self._unknown_fields.is_empty() {
1542 debug_struct.field("_unknown_fields", &self._unknown_fields);
1543 }
1544 debug_struct.finish()
1545 }
1546}
1547
1548impl std::fmt::Debug for super::GenerateRandomBytesRequest {
1549 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1550 let mut debug_struct = f.debug_struct("GenerateRandomBytesRequest");
1551 debug_struct.field("location", &self.location);
1552 debug_struct.field("length_bytes", &self.length_bytes);
1553 debug_struct.field("protection_level", &self.protection_level);
1554 if !self._unknown_fields.is_empty() {
1555 debug_struct.field("_unknown_fields", &self._unknown_fields);
1556 }
1557 debug_struct.finish()
1558 }
1559}
1560
1561impl std::fmt::Debug for super::EncryptResponse {
1562 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563 let mut debug_struct = f.debug_struct("EncryptResponse");
1564 debug_struct.field("name", &self.name);
1565 debug_struct.field("ciphertext", &self.ciphertext);
1566 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1567 debug_struct.field("verified_plaintext_crc32c", &self.verified_plaintext_crc32c);
1568 debug_struct.field(
1569 "verified_additional_authenticated_data_crc32c",
1570 &self.verified_additional_authenticated_data_crc32c,
1571 );
1572 debug_struct.field("protection_level", &self.protection_level);
1573 if !self._unknown_fields.is_empty() {
1574 debug_struct.field("_unknown_fields", &self._unknown_fields);
1575 }
1576 debug_struct.finish()
1577 }
1578}
1579
1580impl std::fmt::Debug for super::DecryptResponse {
1581 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1582 let mut debug_struct = f.debug_struct("DecryptResponse");
1583 debug_struct.field("plaintext", &self.plaintext);
1584 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1585 debug_struct.field("used_primary", &self.used_primary);
1586 debug_struct.field("protection_level", &self.protection_level);
1587 if !self._unknown_fields.is_empty() {
1588 debug_struct.field("_unknown_fields", &self._unknown_fields);
1589 }
1590 debug_struct.finish()
1591 }
1592}
1593
1594impl std::fmt::Debug for super::RawEncryptResponse {
1595 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1596 let mut debug_struct = f.debug_struct("RawEncryptResponse");
1597 debug_struct.field("ciphertext", &self.ciphertext);
1598 debug_struct.field("initialization_vector", &self.initialization_vector);
1599 debug_struct.field("tag_length", &self.tag_length);
1600 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1601 debug_struct.field(
1602 "initialization_vector_crc32c",
1603 &self.initialization_vector_crc32c,
1604 );
1605 debug_struct.field("verified_plaintext_crc32c", &self.verified_plaintext_crc32c);
1606 debug_struct.field(
1607 "verified_additional_authenticated_data_crc32c",
1608 &self.verified_additional_authenticated_data_crc32c,
1609 );
1610 debug_struct.field(
1611 "verified_initialization_vector_crc32c",
1612 &self.verified_initialization_vector_crc32c,
1613 );
1614 debug_struct.field("name", &self.name);
1615 debug_struct.field("protection_level", &self.protection_level);
1616 if !self._unknown_fields.is_empty() {
1617 debug_struct.field("_unknown_fields", &self._unknown_fields);
1618 }
1619 debug_struct.finish()
1620 }
1621}
1622
1623impl std::fmt::Debug for super::RawDecryptResponse {
1624 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1625 let mut debug_struct = f.debug_struct("RawDecryptResponse");
1626 debug_struct.field("plaintext", &self.plaintext);
1627 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1628 debug_struct.field("protection_level", &self.protection_level);
1629 debug_struct.field(
1630 "verified_ciphertext_crc32c",
1631 &self.verified_ciphertext_crc32c,
1632 );
1633 debug_struct.field(
1634 "verified_additional_authenticated_data_crc32c",
1635 &self.verified_additional_authenticated_data_crc32c,
1636 );
1637 debug_struct.field(
1638 "verified_initialization_vector_crc32c",
1639 &self.verified_initialization_vector_crc32c,
1640 );
1641 if !self._unknown_fields.is_empty() {
1642 debug_struct.field("_unknown_fields", &self._unknown_fields);
1643 }
1644 debug_struct.finish()
1645 }
1646}
1647
1648impl std::fmt::Debug for super::AsymmetricSignResponse {
1649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1650 let mut debug_struct = f.debug_struct("AsymmetricSignResponse");
1651 debug_struct.field("signature", &self.signature);
1652 debug_struct.field("signature_crc32c", &self.signature_crc32c);
1653 debug_struct.field("verified_digest_crc32c", &self.verified_digest_crc32c);
1654 debug_struct.field("name", &self.name);
1655 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1656 debug_struct.field("protection_level", &self.protection_level);
1657 if !self._unknown_fields.is_empty() {
1658 debug_struct.field("_unknown_fields", &self._unknown_fields);
1659 }
1660 debug_struct.finish()
1661 }
1662}
1663
1664impl std::fmt::Debug for super::AsymmetricDecryptResponse {
1665 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1666 let mut debug_struct = f.debug_struct("AsymmetricDecryptResponse");
1667 debug_struct.field("plaintext", &self.plaintext);
1668 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1669 debug_struct.field(
1670 "verified_ciphertext_crc32c",
1671 &self.verified_ciphertext_crc32c,
1672 );
1673 debug_struct.field("protection_level", &self.protection_level);
1674 if !self._unknown_fields.is_empty() {
1675 debug_struct.field("_unknown_fields", &self._unknown_fields);
1676 }
1677 debug_struct.finish()
1678 }
1679}
1680
1681impl std::fmt::Debug for super::MacSignResponse {
1682 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1683 let mut debug_struct = f.debug_struct("MacSignResponse");
1684 debug_struct.field("name", &self.name);
1685 debug_struct.field("mac", &self.mac);
1686 debug_struct.field("mac_crc32c", &self.mac_crc32c);
1687 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1688 debug_struct.field("protection_level", &self.protection_level);
1689 if !self._unknown_fields.is_empty() {
1690 debug_struct.field("_unknown_fields", &self._unknown_fields);
1691 }
1692 debug_struct.finish()
1693 }
1694}
1695
1696impl std::fmt::Debug for super::MacVerifyResponse {
1697 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1698 let mut debug_struct = f.debug_struct("MacVerifyResponse");
1699 debug_struct.field("name", &self.name);
1700 debug_struct.field("success", &self.success);
1701 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1702 debug_struct.field("verified_mac_crc32c", &self.verified_mac_crc32c);
1703 debug_struct.field(
1704 "verified_success_integrity",
1705 &self.verified_success_integrity,
1706 );
1707 debug_struct.field("protection_level", &self.protection_level);
1708 if !self._unknown_fields.is_empty() {
1709 debug_struct.field("_unknown_fields", &self._unknown_fields);
1710 }
1711 debug_struct.finish()
1712 }
1713}
1714
1715impl std::fmt::Debug for super::DecapsulateResponse {
1716 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1717 let mut debug_struct = f.debug_struct("DecapsulateResponse");
1718 debug_struct.field("name", &self.name);
1719 debug_struct.field("shared_secret", &self.shared_secret);
1720 debug_struct.field("shared_secret_crc32c", &self.shared_secret_crc32c);
1721 debug_struct.field(
1722 "verified_ciphertext_crc32c",
1723 &self.verified_ciphertext_crc32c,
1724 );
1725 debug_struct.field("protection_level", &self.protection_level);
1726 if !self._unknown_fields.is_empty() {
1727 debug_struct.field("_unknown_fields", &self._unknown_fields);
1728 }
1729 debug_struct.finish()
1730 }
1731}
1732
1733impl std::fmt::Debug for super::GenerateRandomBytesResponse {
1734 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1735 let mut debug_struct = f.debug_struct("GenerateRandomBytesResponse");
1736 debug_struct.field("data", &self.data);
1737 debug_struct.field("data_crc32c", &self.data_crc32c);
1738 if !self._unknown_fields.is_empty() {
1739 debug_struct.field("_unknown_fields", &self._unknown_fields);
1740 }
1741 debug_struct.finish()
1742 }
1743}
1744
1745impl std::fmt::Debug for super::Digest {
1746 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1747 let mut debug_struct = f.debug_struct("Digest");
1748 debug_struct.field("digest", &self.digest);
1749 if !self._unknown_fields.is_empty() {
1750 debug_struct.field("_unknown_fields", &self._unknown_fields);
1751 }
1752 debug_struct.finish()
1753 }
1754}
1755
1756impl std::fmt::Debug for super::LocationMetadata {
1757 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1758 let mut debug_struct = f.debug_struct("LocationMetadata");
1759 debug_struct.field("hsm_available", &self.hsm_available);
1760 debug_struct.field("ekm_available", &self.ekm_available);
1761 debug_struct.field(
1762 "hsm_single_tenant_available",
1763 &self.hsm_single_tenant_available,
1764 );
1765 if !self._unknown_fields.is_empty() {
1766 debug_struct.field("_unknown_fields", &self._unknown_fields);
1767 }
1768 debug_struct.finish()
1769 }
1770}
1771
1772impl std::fmt::Debug for super::DeleteCryptoKeyMetadata {
1773 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1774 let mut debug_struct = f.debug_struct("DeleteCryptoKeyMetadata");
1775 debug_struct.field("retired_resource", &self.retired_resource);
1776 if !self._unknown_fields.is_empty() {
1777 debug_struct.field("_unknown_fields", &self._unknown_fields);
1778 }
1779 debug_struct.finish()
1780 }
1781}
1782
1783impl std::fmt::Debug for super::DeleteCryptoKeyVersionMetadata {
1784 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1785 let mut debug_struct = f.debug_struct("DeleteCryptoKeyVersionMetadata");
1786 if !self._unknown_fields.is_empty() {
1787 debug_struct.field("_unknown_fields", &self._unknown_fields);
1788 }
1789 debug_struct.finish()
1790 }
1791}