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::Challenge {
501 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
502 let mut debug_struct = f.debug_struct("Challenge");
503 debug_struct.field("challenge", &self.challenge);
504 debug_struct.field("public_key_pem", &self.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::ChallengeReply {
513 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
514 let mut debug_struct = f.debug_struct("ChallengeReply");
515 debug_struct.field("signed_challenge", &self.signed_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::ListSingleTenantHsmInstancesRequest {
525 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
526 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstancesRequest");
527 debug_struct.field("parent", &self.parent);
528 debug_struct.field("page_size", &self.page_size);
529 debug_struct.field("page_token", &self.page_token);
530 debug_struct.field("filter", &self.filter);
531 debug_struct.field("order_by", &self.order_by);
532 debug_struct.field("show_deleted", &self.show_deleted);
533 if !self._unknown_fields.is_empty() {
534 debug_struct.field("_unknown_fields", &self._unknown_fields);
535 }
536 debug_struct.finish()
537 }
538}
539
540impl std::fmt::Debug for super::ListSingleTenantHsmInstancesResponse {
541 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
542 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstancesResponse");
543 debug_struct.field(
544 "single_tenant_hsm_instances",
545 &self.single_tenant_hsm_instances,
546 );
547 debug_struct.field("next_page_token", &self.next_page_token);
548 debug_struct.field("total_size", &self.total_size);
549 if !self._unknown_fields.is_empty() {
550 debug_struct.field("_unknown_fields", &self._unknown_fields);
551 }
552 debug_struct.finish()
553 }
554}
555
556impl std::fmt::Debug for super::GetSingleTenantHsmInstanceRequest {
557 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
558 let mut debug_struct = f.debug_struct("GetSingleTenantHsmInstanceRequest");
559 debug_struct.field("name", &self.name);
560 if !self._unknown_fields.is_empty() {
561 debug_struct.field("_unknown_fields", &self._unknown_fields);
562 }
563 debug_struct.finish()
564 }
565}
566
567impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceRequest {
568 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
569 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceRequest");
570 debug_struct.field("parent", &self.parent);
571 debug_struct.field(
572 "single_tenant_hsm_instance_id",
573 &self.single_tenant_hsm_instance_id,
574 );
575 debug_struct.field(
576 "single_tenant_hsm_instance",
577 &self.single_tenant_hsm_instance,
578 );
579 if !self._unknown_fields.is_empty() {
580 debug_struct.field("_unknown_fields", &self._unknown_fields);
581 }
582 debug_struct.finish()
583 }
584}
585
586impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceMetadata {
587 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
588 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceMetadata");
589 if !self._unknown_fields.is_empty() {
590 debug_struct.field("_unknown_fields", &self._unknown_fields);
591 }
592 debug_struct.finish()
593 }
594}
595
596impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceProposalRequest {
597 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
598 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceProposalRequest");
599 debug_struct.field("parent", &self.parent);
600 debug_struct.field(
601 "single_tenant_hsm_instance_proposal_id",
602 &self.single_tenant_hsm_instance_proposal_id,
603 );
604 debug_struct.field(
605 "single_tenant_hsm_instance_proposal",
606 &self.single_tenant_hsm_instance_proposal,
607 );
608 if !self._unknown_fields.is_empty() {
609 debug_struct.field("_unknown_fields", &self._unknown_fields);
610 }
611 debug_struct.finish()
612 }
613}
614
615impl std::fmt::Debug for super::CreateSingleTenantHsmInstanceProposalMetadata {
616 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
617 let mut debug_struct = f.debug_struct("CreateSingleTenantHsmInstanceProposalMetadata");
618 if !self._unknown_fields.is_empty() {
619 debug_struct.field("_unknown_fields", &self._unknown_fields);
620 }
621 debug_struct.finish()
622 }
623}
624
625impl std::fmt::Debug for super::GetSingleTenantHsmInstanceProposalRequest {
626 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
627 let mut debug_struct = f.debug_struct("GetSingleTenantHsmInstanceProposalRequest");
628 debug_struct.field("name", &self.name);
629 if !self._unknown_fields.is_empty() {
630 debug_struct.field("_unknown_fields", &self._unknown_fields);
631 }
632 debug_struct.finish()
633 }
634}
635
636impl std::fmt::Debug for super::ApproveSingleTenantHsmInstanceProposalRequest {
637 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
638 let mut debug_struct = f.debug_struct("ApproveSingleTenantHsmInstanceProposalRequest");
639 debug_struct.field("name", &self.name);
640 debug_struct.field("approval_payload", &self.approval_payload);
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::approve_single_tenant_hsm_instance_proposal_request::QuorumReply {
649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
650 let mut debug_struct = f.debug_struct("QuorumReply");
651 debug_struct.field("challenge_replies", &self.challenge_replies);
652 if !self._unknown_fields.is_empty() {
653 debug_struct.field("_unknown_fields", &self._unknown_fields);
654 }
655 debug_struct.finish()
656 }
657}
658
659impl std::fmt::Debug
660 for super::approve_single_tenant_hsm_instance_proposal_request::RequiredActionQuorumReply
661{
662 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
663 let mut debug_struct = f.debug_struct("RequiredActionQuorumReply");
664 debug_struct.field(
665 "required_challenge_replies",
666 &self.required_challenge_replies,
667 );
668 debug_struct.field("quorum_challenge_replies", &self.quorum_challenge_replies);
669 if !self._unknown_fields.is_empty() {
670 debug_struct.field("_unknown_fields", &self._unknown_fields);
671 }
672 debug_struct.finish()
673 }
674}
675
676impl std::fmt::Debug for super::ApproveSingleTenantHsmInstanceProposalResponse {
677 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
678 let mut debug_struct = f.debug_struct("ApproveSingleTenantHsmInstanceProposalResponse");
679 if !self._unknown_fields.is_empty() {
680 debug_struct.field("_unknown_fields", &self._unknown_fields);
681 }
682 debug_struct.finish()
683 }
684}
685
686impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalRequest {
687 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
688 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalRequest");
689 debug_struct.field("name", &self.name);
690 if !self._unknown_fields.is_empty() {
691 debug_struct.field("_unknown_fields", &self._unknown_fields);
692 }
693 debug_struct.finish()
694 }
695}
696
697impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalResponse {
698 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
699 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalResponse");
700 if !self._unknown_fields.is_empty() {
701 debug_struct.field("_unknown_fields", &self._unknown_fields);
702 }
703 debug_struct.finish()
704 }
705}
706
707impl std::fmt::Debug for super::ExecuteSingleTenantHsmInstanceProposalMetadata {
708 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
709 let mut debug_struct = f.debug_struct("ExecuteSingleTenantHsmInstanceProposalMetadata");
710 if !self._unknown_fields.is_empty() {
711 debug_struct.field("_unknown_fields", &self._unknown_fields);
712 }
713 debug_struct.finish()
714 }
715}
716
717impl std::fmt::Debug for super::ListSingleTenantHsmInstanceProposalsRequest {
718 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
719 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstanceProposalsRequest");
720 debug_struct.field("parent", &self.parent);
721 debug_struct.field("page_size", &self.page_size);
722 debug_struct.field("page_token", &self.page_token);
723 debug_struct.field("filter", &self.filter);
724 debug_struct.field("order_by", &self.order_by);
725 debug_struct.field("show_deleted", &self.show_deleted);
726 if !self._unknown_fields.is_empty() {
727 debug_struct.field("_unknown_fields", &self._unknown_fields);
728 }
729 debug_struct.finish()
730 }
731}
732
733impl std::fmt::Debug for super::ListSingleTenantHsmInstanceProposalsResponse {
734 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
735 let mut debug_struct = f.debug_struct("ListSingleTenantHsmInstanceProposalsResponse");
736 debug_struct.field(
737 "single_tenant_hsm_instance_proposals",
738 &self.single_tenant_hsm_instance_proposals,
739 );
740 debug_struct.field("next_page_token", &self.next_page_token);
741 debug_struct.field("total_size", &self.total_size);
742 if !self._unknown_fields.is_empty() {
743 debug_struct.field("_unknown_fields", &self._unknown_fields);
744 }
745 debug_struct.finish()
746 }
747}
748
749impl std::fmt::Debug for super::DeleteSingleTenantHsmInstanceProposalRequest {
750 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
751 let mut debug_struct = f.debug_struct("DeleteSingleTenantHsmInstanceProposalRequest");
752 debug_struct.field("name", &self.name);
753 if !self._unknown_fields.is_empty() {
754 debug_struct.field("_unknown_fields", &self._unknown_fields);
755 }
756 debug_struct.finish()
757 }
758}
759
760impl std::fmt::Debug for super::KeyRing {
761 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
762 let mut debug_struct = f.debug_struct("KeyRing");
763 debug_struct.field("name", &self.name);
764 debug_struct.field("create_time", &self.create_time);
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::CryptoKey {
773 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774 let mut debug_struct = f.debug_struct("CryptoKey");
775 debug_struct.field("name", &self.name);
776 debug_struct.field("primary", &self.primary);
777 debug_struct.field("purpose", &self.purpose);
778 debug_struct.field("create_time", &self.create_time);
779 debug_struct.field("next_rotation_time", &self.next_rotation_time);
780 debug_struct.field("version_template", &self.version_template);
781 debug_struct.field("labels", &self.labels);
782 debug_struct.field("import_only", &self.import_only);
783 debug_struct.field(
784 "destroy_scheduled_duration",
785 &self.destroy_scheduled_duration,
786 );
787 debug_struct.field("crypto_key_backend", &self.crypto_key_backend);
788 debug_struct.field(
789 "key_access_justifications_policy",
790 &self.key_access_justifications_policy,
791 );
792 debug_struct.field("rotation_schedule", &self.rotation_schedule);
793 if !self._unknown_fields.is_empty() {
794 debug_struct.field("_unknown_fields", &self._unknown_fields);
795 }
796 debug_struct.finish()
797 }
798}
799
800impl std::fmt::Debug for super::CryptoKeyVersionTemplate {
801 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
802 let mut debug_struct = f.debug_struct("CryptoKeyVersionTemplate");
803 debug_struct.field("protection_level", &self.protection_level);
804 debug_struct.field("algorithm", &self.algorithm);
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::KeyOperationAttestation {
813 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
814 let mut debug_struct = f.debug_struct("KeyOperationAttestation");
815 debug_struct.field("format", &self.format);
816 debug_struct.field("content", &self.content);
817 debug_struct.field("cert_chains", &self.cert_chains);
818 if !self._unknown_fields.is_empty() {
819 debug_struct.field("_unknown_fields", &self._unknown_fields);
820 }
821 debug_struct.finish()
822 }
823}
824
825impl std::fmt::Debug for super::key_operation_attestation::CertificateChains {
826 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 let mut debug_struct = f.debug_struct("CertificateChains");
828 debug_struct.field("cavium_certs", &self.cavium_certs);
829 debug_struct.field("google_card_certs", &self.google_card_certs);
830 debug_struct.field("google_partition_certs", &self.google_partition_certs);
831 if !self._unknown_fields.is_empty() {
832 debug_struct.field("_unknown_fields", &self._unknown_fields);
833 }
834 debug_struct.finish()
835 }
836}
837
838impl std::fmt::Debug for super::CryptoKeyVersion {
839 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
840 let mut debug_struct = f.debug_struct("CryptoKeyVersion");
841 debug_struct.field("name", &self.name);
842 debug_struct.field("state", &self.state);
843 debug_struct.field("protection_level", &self.protection_level);
844 debug_struct.field("algorithm", &self.algorithm);
845 debug_struct.field("attestation", &self.attestation);
846 debug_struct.field("create_time", &self.create_time);
847 debug_struct.field("generate_time", &self.generate_time);
848 debug_struct.field("destroy_time", &self.destroy_time);
849 debug_struct.field("destroy_event_time", &self.destroy_event_time);
850 debug_struct.field("import_job", &self.import_job);
851 debug_struct.field("import_time", &self.import_time);
852 debug_struct.field("import_failure_reason", &self.import_failure_reason);
853 debug_struct.field("generation_failure_reason", &self.generation_failure_reason);
854 debug_struct.field(
855 "external_destruction_failure_reason",
856 &self.external_destruction_failure_reason,
857 );
858 debug_struct.field(
859 "external_protection_level_options",
860 &self.external_protection_level_options,
861 );
862 debug_struct.field("reimport_eligible", &self.reimport_eligible);
863 if !self._unknown_fields.is_empty() {
864 debug_struct.field("_unknown_fields", &self._unknown_fields);
865 }
866 debug_struct.finish()
867 }
868}
869
870impl std::fmt::Debug for super::ChecksummedData {
871 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
872 let mut debug_struct = f.debug_struct("ChecksummedData");
873 debug_struct.field("data", &self.data);
874 debug_struct.field("crc32c_checksum", &self.crc32c_checksum);
875 if !self._unknown_fields.is_empty() {
876 debug_struct.field("_unknown_fields", &self._unknown_fields);
877 }
878 debug_struct.finish()
879 }
880}
881
882impl std::fmt::Debug for super::PublicKey {
883 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
884 let mut debug_struct = f.debug_struct("PublicKey");
885 debug_struct.field("pem", &self.pem);
886 debug_struct.field("algorithm", &self.algorithm);
887 debug_struct.field("pem_crc32c", &self.pem_crc32c);
888 debug_struct.field("name", &self.name);
889 debug_struct.field("protection_level", &self.protection_level);
890 debug_struct.field("public_key_format", &self.public_key_format);
891 debug_struct.field("public_key", &self.public_key);
892 if !self._unknown_fields.is_empty() {
893 debug_struct.field("_unknown_fields", &self._unknown_fields);
894 }
895 debug_struct.finish()
896 }
897}
898
899impl std::fmt::Debug for super::ImportJob {
900 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
901 let mut debug_struct = f.debug_struct("ImportJob");
902 debug_struct.field("name", &self.name);
903 debug_struct.field("import_method", &self.import_method);
904 debug_struct.field("protection_level", &self.protection_level);
905 debug_struct.field("create_time", &self.create_time);
906 debug_struct.field("generate_time", &self.generate_time);
907 debug_struct.field("expire_time", &self.expire_time);
908 debug_struct.field("expire_event_time", &self.expire_event_time);
909 debug_struct.field("state", &self.state);
910 debug_struct.field("public_key", &self.public_key);
911 debug_struct.field("attestation", &self.attestation);
912 debug_struct.field("crypto_key_backend", &self.crypto_key_backend);
913 if !self._unknown_fields.is_empty() {
914 debug_struct.field("_unknown_fields", &self._unknown_fields);
915 }
916 debug_struct.finish()
917 }
918}
919
920impl std::fmt::Debug for super::import_job::WrappingPublicKey {
921 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
922 let mut debug_struct = f.debug_struct("WrappingPublicKey");
923 debug_struct.field("pem", &self.pem);
924 if !self._unknown_fields.is_empty() {
925 debug_struct.field("_unknown_fields", &self._unknown_fields);
926 }
927 debug_struct.finish()
928 }
929}
930
931impl std::fmt::Debug for super::ExternalProtectionLevelOptions {
932 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
933 let mut debug_struct = f.debug_struct("ExternalProtectionLevelOptions");
934 debug_struct.field("external_key_uri", &self.external_key_uri);
935 debug_struct.field("ekm_connection_key_path", &self.ekm_connection_key_path);
936 if !self._unknown_fields.is_empty() {
937 debug_struct.field("_unknown_fields", &self._unknown_fields);
938 }
939 debug_struct.finish()
940 }
941}
942
943impl std::fmt::Debug for super::KeyAccessJustificationsPolicy {
944 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
945 let mut debug_struct = f.debug_struct("KeyAccessJustificationsPolicy");
946 debug_struct.field("allowed_access_reasons", &self.allowed_access_reasons);
947 if !self._unknown_fields.is_empty() {
948 debug_struct.field("_unknown_fields", &self._unknown_fields);
949 }
950 debug_struct.finish()
951 }
952}
953
954impl std::fmt::Debug for super::RetiredResource {
955 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
956 let mut debug_struct = f.debug_struct("RetiredResource");
957 debug_struct.field("name", &self.name);
958 debug_struct.field("original_resource", &self.original_resource);
959 debug_struct.field("resource_type", &self.resource_type);
960 debug_struct.field("delete_time", &self.delete_time);
961 if !self._unknown_fields.is_empty() {
962 debug_struct.field("_unknown_fields", &self._unknown_fields);
963 }
964 debug_struct.finish()
965 }
966}
967
968impl std::fmt::Debug for super::ListKeyRingsRequest {
969 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
970 let mut debug_struct = f.debug_struct("ListKeyRingsRequest");
971 debug_struct.field("parent", &self.parent);
972 debug_struct.field("page_size", &self.page_size);
973 debug_struct.field("page_token", &self.page_token);
974 debug_struct.field("filter", &self.filter);
975 debug_struct.field("order_by", &self.order_by);
976 if !self._unknown_fields.is_empty() {
977 debug_struct.field("_unknown_fields", &self._unknown_fields);
978 }
979 debug_struct.finish()
980 }
981}
982
983impl std::fmt::Debug for super::ListCryptoKeysRequest {
984 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
985 let mut debug_struct = f.debug_struct("ListCryptoKeysRequest");
986 debug_struct.field("parent", &self.parent);
987 debug_struct.field("page_size", &self.page_size);
988 debug_struct.field("page_token", &self.page_token);
989 debug_struct.field("version_view", &self.version_view);
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::ListCryptoKeyVersionsRequest {
1000 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1001 let mut debug_struct = f.debug_struct("ListCryptoKeyVersionsRequest");
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("view", &self.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::ListImportJobsRequest {
1016 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1017 let mut debug_struct = f.debug_struct("ListImportJobsRequest");
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("filter", &self.filter);
1022 debug_struct.field("order_by", &self.order_by);
1023 if !self._unknown_fields.is_empty() {
1024 debug_struct.field("_unknown_fields", &self._unknown_fields);
1025 }
1026 debug_struct.finish()
1027 }
1028}
1029
1030impl std::fmt::Debug for super::ListRetiredResourcesRequest {
1031 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1032 let mut debug_struct = f.debug_struct("ListRetiredResourcesRequest");
1033 debug_struct.field("parent", &self.parent);
1034 debug_struct.field("page_size", &self.page_size);
1035 debug_struct.field("page_token", &self.page_token);
1036 if !self._unknown_fields.is_empty() {
1037 debug_struct.field("_unknown_fields", &self._unknown_fields);
1038 }
1039 debug_struct.finish()
1040 }
1041}
1042
1043impl std::fmt::Debug for super::ListKeyRingsResponse {
1044 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1045 let mut debug_struct = f.debug_struct("ListKeyRingsResponse");
1046 debug_struct.field("key_rings", &self.key_rings);
1047 debug_struct.field("next_page_token", &self.next_page_token);
1048 debug_struct.field("total_size", &self.total_size);
1049 if !self._unknown_fields.is_empty() {
1050 debug_struct.field("_unknown_fields", &self._unknown_fields);
1051 }
1052 debug_struct.finish()
1053 }
1054}
1055
1056impl std::fmt::Debug for super::ListCryptoKeysResponse {
1057 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1058 let mut debug_struct = f.debug_struct("ListCryptoKeysResponse");
1059 debug_struct.field("crypto_keys", &self.crypto_keys);
1060 debug_struct.field("next_page_token", &self.next_page_token);
1061 debug_struct.field("total_size", &self.total_size);
1062 if !self._unknown_fields.is_empty() {
1063 debug_struct.field("_unknown_fields", &self._unknown_fields);
1064 }
1065 debug_struct.finish()
1066 }
1067}
1068
1069impl std::fmt::Debug for super::ListCryptoKeyVersionsResponse {
1070 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1071 let mut debug_struct = f.debug_struct("ListCryptoKeyVersionsResponse");
1072 debug_struct.field("crypto_key_versions", &self.crypto_key_versions);
1073 debug_struct.field("next_page_token", &self.next_page_token);
1074 debug_struct.field("total_size", &self.total_size);
1075 if !self._unknown_fields.is_empty() {
1076 debug_struct.field("_unknown_fields", &self._unknown_fields);
1077 }
1078 debug_struct.finish()
1079 }
1080}
1081
1082impl std::fmt::Debug for super::ListImportJobsResponse {
1083 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1084 let mut debug_struct = f.debug_struct("ListImportJobsResponse");
1085 debug_struct.field("import_jobs", &self.import_jobs);
1086 debug_struct.field("next_page_token", &self.next_page_token);
1087 debug_struct.field("total_size", &self.total_size);
1088 if !self._unknown_fields.is_empty() {
1089 debug_struct.field("_unknown_fields", &self._unknown_fields);
1090 }
1091 debug_struct.finish()
1092 }
1093}
1094
1095impl std::fmt::Debug for super::ListRetiredResourcesResponse {
1096 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1097 let mut debug_struct = f.debug_struct("ListRetiredResourcesResponse");
1098 debug_struct.field("retired_resources", &self.retired_resources);
1099 debug_struct.field("next_page_token", &self.next_page_token);
1100 debug_struct.field("total_size", &self.total_size);
1101 if !self._unknown_fields.is_empty() {
1102 debug_struct.field("_unknown_fields", &self._unknown_fields);
1103 }
1104 debug_struct.finish()
1105 }
1106}
1107
1108impl std::fmt::Debug for super::GetKeyRingRequest {
1109 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1110 let mut debug_struct = f.debug_struct("GetKeyRingRequest");
1111 debug_struct.field("name", &self.name);
1112 if !self._unknown_fields.is_empty() {
1113 debug_struct.field("_unknown_fields", &self._unknown_fields);
1114 }
1115 debug_struct.finish()
1116 }
1117}
1118
1119impl std::fmt::Debug for super::GetCryptoKeyRequest {
1120 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1121 let mut debug_struct = f.debug_struct("GetCryptoKeyRequest");
1122 debug_struct.field("name", &self.name);
1123 if !self._unknown_fields.is_empty() {
1124 debug_struct.field("_unknown_fields", &self._unknown_fields);
1125 }
1126 debug_struct.finish()
1127 }
1128}
1129
1130impl std::fmt::Debug for super::GetCryptoKeyVersionRequest {
1131 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1132 let mut debug_struct = f.debug_struct("GetCryptoKeyVersionRequest");
1133 debug_struct.field("name", &self.name);
1134 if !self._unknown_fields.is_empty() {
1135 debug_struct.field("_unknown_fields", &self._unknown_fields);
1136 }
1137 debug_struct.finish()
1138 }
1139}
1140
1141impl std::fmt::Debug for super::GetPublicKeyRequest {
1142 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1143 let mut debug_struct = f.debug_struct("GetPublicKeyRequest");
1144 debug_struct.field("name", &self.name);
1145 debug_struct.field("public_key_format", &self.public_key_format);
1146 if !self._unknown_fields.is_empty() {
1147 debug_struct.field("_unknown_fields", &self._unknown_fields);
1148 }
1149 debug_struct.finish()
1150 }
1151}
1152
1153impl std::fmt::Debug for super::GetImportJobRequest {
1154 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1155 let mut debug_struct = f.debug_struct("GetImportJobRequest");
1156 debug_struct.field("name", &self.name);
1157 if !self._unknown_fields.is_empty() {
1158 debug_struct.field("_unknown_fields", &self._unknown_fields);
1159 }
1160 debug_struct.finish()
1161 }
1162}
1163
1164impl std::fmt::Debug for super::GetRetiredResourceRequest {
1165 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1166 let mut debug_struct = f.debug_struct("GetRetiredResourceRequest");
1167 debug_struct.field("name", &self.name);
1168 if !self._unknown_fields.is_empty() {
1169 debug_struct.field("_unknown_fields", &self._unknown_fields);
1170 }
1171 debug_struct.finish()
1172 }
1173}
1174
1175impl std::fmt::Debug for super::CreateKeyRingRequest {
1176 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1177 let mut debug_struct = f.debug_struct("CreateKeyRingRequest");
1178 debug_struct.field("parent", &self.parent);
1179 debug_struct.field("key_ring_id", &self.key_ring_id);
1180 debug_struct.field("key_ring", &self.key_ring);
1181 if !self._unknown_fields.is_empty() {
1182 debug_struct.field("_unknown_fields", &self._unknown_fields);
1183 }
1184 debug_struct.finish()
1185 }
1186}
1187
1188impl std::fmt::Debug for super::CreateCryptoKeyRequest {
1189 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1190 let mut debug_struct = f.debug_struct("CreateCryptoKeyRequest");
1191 debug_struct.field("parent", &self.parent);
1192 debug_struct.field("crypto_key_id", &self.crypto_key_id);
1193 debug_struct.field("crypto_key", &self.crypto_key);
1194 debug_struct.field(
1195 "skip_initial_version_creation",
1196 &self.skip_initial_version_creation,
1197 );
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::CreateCryptoKeyVersionRequest {
1206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1207 let mut debug_struct = f.debug_struct("CreateCryptoKeyVersionRequest");
1208 debug_struct.field("parent", &self.parent);
1209 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1210 if !self._unknown_fields.is_empty() {
1211 debug_struct.field("_unknown_fields", &self._unknown_fields);
1212 }
1213 debug_struct.finish()
1214 }
1215}
1216
1217impl std::fmt::Debug for super::DeleteCryptoKeyRequest {
1218 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1219 let mut debug_struct = f.debug_struct("DeleteCryptoKeyRequest");
1220 debug_struct.field("name", &self.name);
1221 if !self._unknown_fields.is_empty() {
1222 debug_struct.field("_unknown_fields", &self._unknown_fields);
1223 }
1224 debug_struct.finish()
1225 }
1226}
1227
1228impl std::fmt::Debug for super::DeleteCryptoKeyVersionRequest {
1229 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1230 let mut debug_struct = f.debug_struct("DeleteCryptoKeyVersionRequest");
1231 debug_struct.field("name", &self.name);
1232 if !self._unknown_fields.is_empty() {
1233 debug_struct.field("_unknown_fields", &self._unknown_fields);
1234 }
1235 debug_struct.finish()
1236 }
1237}
1238
1239impl std::fmt::Debug for super::ImportCryptoKeyVersionRequest {
1240 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1241 let mut debug_struct = f.debug_struct("ImportCryptoKeyVersionRequest");
1242 debug_struct.field("parent", &self.parent);
1243 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1244 debug_struct.field("algorithm", &self.algorithm);
1245 debug_struct.field("import_job", &self.import_job);
1246 debug_struct.field("wrapped_key", &self.wrapped_key);
1247 debug_struct.field("wrapped_key_material", &self.wrapped_key_material);
1248 if !self._unknown_fields.is_empty() {
1249 debug_struct.field("_unknown_fields", &self._unknown_fields);
1250 }
1251 debug_struct.finish()
1252 }
1253}
1254
1255impl std::fmt::Debug for super::CreateImportJobRequest {
1256 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1257 let mut debug_struct = f.debug_struct("CreateImportJobRequest");
1258 debug_struct.field("parent", &self.parent);
1259 debug_struct.field("import_job_id", &self.import_job_id);
1260 debug_struct.field("import_job", &self.import_job);
1261 if !self._unknown_fields.is_empty() {
1262 debug_struct.field("_unknown_fields", &self._unknown_fields);
1263 }
1264 debug_struct.finish()
1265 }
1266}
1267
1268impl std::fmt::Debug for super::UpdateCryptoKeyRequest {
1269 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1270 let mut debug_struct = f.debug_struct("UpdateCryptoKeyRequest");
1271 debug_struct.field("crypto_key", &self.crypto_key);
1272 debug_struct.field("update_mask", &self.update_mask);
1273 if !self._unknown_fields.is_empty() {
1274 debug_struct.field("_unknown_fields", &self._unknown_fields);
1275 }
1276 debug_struct.finish()
1277 }
1278}
1279
1280impl std::fmt::Debug for super::UpdateCryptoKeyVersionRequest {
1281 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1282 let mut debug_struct = f.debug_struct("UpdateCryptoKeyVersionRequest");
1283 debug_struct.field("crypto_key_version", &self.crypto_key_version);
1284 debug_struct.field("update_mask", &self.update_mask);
1285 if !self._unknown_fields.is_empty() {
1286 debug_struct.field("_unknown_fields", &self._unknown_fields);
1287 }
1288 debug_struct.finish()
1289 }
1290}
1291
1292impl std::fmt::Debug for super::UpdateCryptoKeyPrimaryVersionRequest {
1293 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1294 let mut debug_struct = f.debug_struct("UpdateCryptoKeyPrimaryVersionRequest");
1295 debug_struct.field("name", &self.name);
1296 debug_struct.field("crypto_key_version_id", &self.crypto_key_version_id);
1297 if !self._unknown_fields.is_empty() {
1298 debug_struct.field("_unknown_fields", &self._unknown_fields);
1299 }
1300 debug_struct.finish()
1301 }
1302}
1303
1304impl std::fmt::Debug for super::DestroyCryptoKeyVersionRequest {
1305 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1306 let mut debug_struct = f.debug_struct("DestroyCryptoKeyVersionRequest");
1307 debug_struct.field("name", &self.name);
1308 if !self._unknown_fields.is_empty() {
1309 debug_struct.field("_unknown_fields", &self._unknown_fields);
1310 }
1311 debug_struct.finish()
1312 }
1313}
1314
1315impl std::fmt::Debug for super::RestoreCryptoKeyVersionRequest {
1316 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1317 let mut debug_struct = f.debug_struct("RestoreCryptoKeyVersionRequest");
1318 debug_struct.field("name", &self.name);
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::EncryptRequest {
1327 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1328 let mut debug_struct = f.debug_struct("EncryptRequest");
1329 debug_struct.field("name", &self.name);
1330 debug_struct.field("plaintext", &self.plaintext);
1331 debug_struct.field(
1332 "additional_authenticated_data",
1333 &self.additional_authenticated_data,
1334 );
1335 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1336 debug_struct.field(
1337 "additional_authenticated_data_crc32c",
1338 &self.additional_authenticated_data_crc32c,
1339 );
1340 if !self._unknown_fields.is_empty() {
1341 debug_struct.field("_unknown_fields", &self._unknown_fields);
1342 }
1343 debug_struct.finish()
1344 }
1345}
1346
1347impl std::fmt::Debug for super::DecryptRequest {
1348 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1349 let mut debug_struct = f.debug_struct("DecryptRequest");
1350 debug_struct.field("name", &self.name);
1351 debug_struct.field("ciphertext", &self.ciphertext);
1352 debug_struct.field(
1353 "additional_authenticated_data",
1354 &self.additional_authenticated_data,
1355 );
1356 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1357 debug_struct.field(
1358 "additional_authenticated_data_crc32c",
1359 &self.additional_authenticated_data_crc32c,
1360 );
1361 if !self._unknown_fields.is_empty() {
1362 debug_struct.field("_unknown_fields", &self._unknown_fields);
1363 }
1364 debug_struct.finish()
1365 }
1366}
1367
1368impl std::fmt::Debug for super::RawEncryptRequest {
1369 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1370 let mut debug_struct = f.debug_struct("RawEncryptRequest");
1371 debug_struct.field("name", &self.name);
1372 debug_struct.field("plaintext", &self.plaintext);
1373 debug_struct.field(
1374 "additional_authenticated_data",
1375 &self.additional_authenticated_data,
1376 );
1377 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1378 debug_struct.field(
1379 "additional_authenticated_data_crc32c",
1380 &self.additional_authenticated_data_crc32c,
1381 );
1382 debug_struct.field("initialization_vector", &self.initialization_vector);
1383 debug_struct.field(
1384 "initialization_vector_crc32c",
1385 &self.initialization_vector_crc32c,
1386 );
1387 if !self._unknown_fields.is_empty() {
1388 debug_struct.field("_unknown_fields", &self._unknown_fields);
1389 }
1390 debug_struct.finish()
1391 }
1392}
1393
1394impl std::fmt::Debug for super::RawDecryptRequest {
1395 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1396 let mut debug_struct = f.debug_struct("RawDecryptRequest");
1397 debug_struct.field("name", &self.name);
1398 debug_struct.field("ciphertext", &self.ciphertext);
1399 debug_struct.field(
1400 "additional_authenticated_data",
1401 &self.additional_authenticated_data,
1402 );
1403 debug_struct.field("initialization_vector", &self.initialization_vector);
1404 debug_struct.field("tag_length", &self.tag_length);
1405 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1406 debug_struct.field(
1407 "additional_authenticated_data_crc32c",
1408 &self.additional_authenticated_data_crc32c,
1409 );
1410 debug_struct.field(
1411 "initialization_vector_crc32c",
1412 &self.initialization_vector_crc32c,
1413 );
1414 if !self._unknown_fields.is_empty() {
1415 debug_struct.field("_unknown_fields", &self._unknown_fields);
1416 }
1417 debug_struct.finish()
1418 }
1419}
1420
1421impl std::fmt::Debug for super::AsymmetricSignRequest {
1422 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1423 let mut debug_struct = f.debug_struct("AsymmetricSignRequest");
1424 debug_struct.field("name", &self.name);
1425 debug_struct.field("digest", &self.digest);
1426 debug_struct.field("digest_crc32c", &self.digest_crc32c);
1427 debug_struct.field("data", &self.data);
1428 debug_struct.field("data_crc32c", &self.data_crc32c);
1429 if !self._unknown_fields.is_empty() {
1430 debug_struct.field("_unknown_fields", &self._unknown_fields);
1431 }
1432 debug_struct.finish()
1433 }
1434}
1435
1436impl std::fmt::Debug for super::AsymmetricDecryptRequest {
1437 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1438 let mut debug_struct = f.debug_struct("AsymmetricDecryptRequest");
1439 debug_struct.field("name", &self.name);
1440 debug_struct.field("ciphertext", &self.ciphertext);
1441 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1442 if !self._unknown_fields.is_empty() {
1443 debug_struct.field("_unknown_fields", &self._unknown_fields);
1444 }
1445 debug_struct.finish()
1446 }
1447}
1448
1449impl std::fmt::Debug for super::MacSignRequest {
1450 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1451 let mut debug_struct = f.debug_struct("MacSignRequest");
1452 debug_struct.field("name", &self.name);
1453 debug_struct.field("data", &self.data);
1454 debug_struct.field("data_crc32c", &self.data_crc32c);
1455 if !self._unknown_fields.is_empty() {
1456 debug_struct.field("_unknown_fields", &self._unknown_fields);
1457 }
1458 debug_struct.finish()
1459 }
1460}
1461
1462impl std::fmt::Debug for super::MacVerifyRequest {
1463 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1464 let mut debug_struct = f.debug_struct("MacVerifyRequest");
1465 debug_struct.field("name", &self.name);
1466 debug_struct.field("data", &self.data);
1467 debug_struct.field("data_crc32c", &self.data_crc32c);
1468 debug_struct.field("mac", &self.mac);
1469 debug_struct.field("mac_crc32c", &self.mac_crc32c);
1470 if !self._unknown_fields.is_empty() {
1471 debug_struct.field("_unknown_fields", &self._unknown_fields);
1472 }
1473 debug_struct.finish()
1474 }
1475}
1476
1477impl std::fmt::Debug for super::DecapsulateRequest {
1478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 let mut debug_struct = f.debug_struct("DecapsulateRequest");
1480 debug_struct.field("name", &self.name);
1481 debug_struct.field("ciphertext", &self.ciphertext);
1482 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1483 if !self._unknown_fields.is_empty() {
1484 debug_struct.field("_unknown_fields", &self._unknown_fields);
1485 }
1486 debug_struct.finish()
1487 }
1488}
1489
1490impl std::fmt::Debug for super::GenerateRandomBytesRequest {
1491 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1492 let mut debug_struct = f.debug_struct("GenerateRandomBytesRequest");
1493 debug_struct.field("location", &self.location);
1494 debug_struct.field("length_bytes", &self.length_bytes);
1495 debug_struct.field("protection_level", &self.protection_level);
1496 if !self._unknown_fields.is_empty() {
1497 debug_struct.field("_unknown_fields", &self._unknown_fields);
1498 }
1499 debug_struct.finish()
1500 }
1501}
1502
1503impl std::fmt::Debug for super::EncryptResponse {
1504 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1505 let mut debug_struct = f.debug_struct("EncryptResponse");
1506 debug_struct.field("name", &self.name);
1507 debug_struct.field("ciphertext", &self.ciphertext);
1508 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1509 debug_struct.field("verified_plaintext_crc32c", &self.verified_plaintext_crc32c);
1510 debug_struct.field(
1511 "verified_additional_authenticated_data_crc32c",
1512 &self.verified_additional_authenticated_data_crc32c,
1513 );
1514 debug_struct.field("protection_level", &self.protection_level);
1515 if !self._unknown_fields.is_empty() {
1516 debug_struct.field("_unknown_fields", &self._unknown_fields);
1517 }
1518 debug_struct.finish()
1519 }
1520}
1521
1522impl std::fmt::Debug for super::DecryptResponse {
1523 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1524 let mut debug_struct = f.debug_struct("DecryptResponse");
1525 debug_struct.field("plaintext", &self.plaintext);
1526 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1527 debug_struct.field("used_primary", &self.used_primary);
1528 debug_struct.field("protection_level", &self.protection_level);
1529 if !self._unknown_fields.is_empty() {
1530 debug_struct.field("_unknown_fields", &self._unknown_fields);
1531 }
1532 debug_struct.finish()
1533 }
1534}
1535
1536impl std::fmt::Debug for super::RawEncryptResponse {
1537 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1538 let mut debug_struct = f.debug_struct("RawEncryptResponse");
1539 debug_struct.field("ciphertext", &self.ciphertext);
1540 debug_struct.field("initialization_vector", &self.initialization_vector);
1541 debug_struct.field("tag_length", &self.tag_length);
1542 debug_struct.field("ciphertext_crc32c", &self.ciphertext_crc32c);
1543 debug_struct.field(
1544 "initialization_vector_crc32c",
1545 &self.initialization_vector_crc32c,
1546 );
1547 debug_struct.field("verified_plaintext_crc32c", &self.verified_plaintext_crc32c);
1548 debug_struct.field(
1549 "verified_additional_authenticated_data_crc32c",
1550 &self.verified_additional_authenticated_data_crc32c,
1551 );
1552 debug_struct.field(
1553 "verified_initialization_vector_crc32c",
1554 &self.verified_initialization_vector_crc32c,
1555 );
1556 debug_struct.field("name", &self.name);
1557 debug_struct.field("protection_level", &self.protection_level);
1558 if !self._unknown_fields.is_empty() {
1559 debug_struct.field("_unknown_fields", &self._unknown_fields);
1560 }
1561 debug_struct.finish()
1562 }
1563}
1564
1565impl std::fmt::Debug for super::RawDecryptResponse {
1566 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1567 let mut debug_struct = f.debug_struct("RawDecryptResponse");
1568 debug_struct.field("plaintext", &self.plaintext);
1569 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1570 debug_struct.field("protection_level", &self.protection_level);
1571 debug_struct.field(
1572 "verified_ciphertext_crc32c",
1573 &self.verified_ciphertext_crc32c,
1574 );
1575 debug_struct.field(
1576 "verified_additional_authenticated_data_crc32c",
1577 &self.verified_additional_authenticated_data_crc32c,
1578 );
1579 debug_struct.field(
1580 "verified_initialization_vector_crc32c",
1581 &self.verified_initialization_vector_crc32c,
1582 );
1583 if !self._unknown_fields.is_empty() {
1584 debug_struct.field("_unknown_fields", &self._unknown_fields);
1585 }
1586 debug_struct.finish()
1587 }
1588}
1589
1590impl std::fmt::Debug for super::AsymmetricSignResponse {
1591 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1592 let mut debug_struct = f.debug_struct("AsymmetricSignResponse");
1593 debug_struct.field("signature", &self.signature);
1594 debug_struct.field("signature_crc32c", &self.signature_crc32c);
1595 debug_struct.field("verified_digest_crc32c", &self.verified_digest_crc32c);
1596 debug_struct.field("name", &self.name);
1597 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1598 debug_struct.field("protection_level", &self.protection_level);
1599 if !self._unknown_fields.is_empty() {
1600 debug_struct.field("_unknown_fields", &self._unknown_fields);
1601 }
1602 debug_struct.finish()
1603 }
1604}
1605
1606impl std::fmt::Debug for super::AsymmetricDecryptResponse {
1607 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1608 let mut debug_struct = f.debug_struct("AsymmetricDecryptResponse");
1609 debug_struct.field("plaintext", &self.plaintext);
1610 debug_struct.field("plaintext_crc32c", &self.plaintext_crc32c);
1611 debug_struct.field(
1612 "verified_ciphertext_crc32c",
1613 &self.verified_ciphertext_crc32c,
1614 );
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::MacSignResponse {
1624 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1625 let mut debug_struct = f.debug_struct("MacSignResponse");
1626 debug_struct.field("name", &self.name);
1627 debug_struct.field("mac", &self.mac);
1628 debug_struct.field("mac_crc32c", &self.mac_crc32c);
1629 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1630 debug_struct.field("protection_level", &self.protection_level);
1631 if !self._unknown_fields.is_empty() {
1632 debug_struct.field("_unknown_fields", &self._unknown_fields);
1633 }
1634 debug_struct.finish()
1635 }
1636}
1637
1638impl std::fmt::Debug for super::MacVerifyResponse {
1639 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1640 let mut debug_struct = f.debug_struct("MacVerifyResponse");
1641 debug_struct.field("name", &self.name);
1642 debug_struct.field("success", &self.success);
1643 debug_struct.field("verified_data_crc32c", &self.verified_data_crc32c);
1644 debug_struct.field("verified_mac_crc32c", &self.verified_mac_crc32c);
1645 debug_struct.field(
1646 "verified_success_integrity",
1647 &self.verified_success_integrity,
1648 );
1649 debug_struct.field("protection_level", &self.protection_level);
1650 if !self._unknown_fields.is_empty() {
1651 debug_struct.field("_unknown_fields", &self._unknown_fields);
1652 }
1653 debug_struct.finish()
1654 }
1655}
1656
1657impl std::fmt::Debug for super::DecapsulateResponse {
1658 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1659 let mut debug_struct = f.debug_struct("DecapsulateResponse");
1660 debug_struct.field("name", &self.name);
1661 debug_struct.field("shared_secret", &self.shared_secret);
1662 debug_struct.field("shared_secret_crc32c", &self.shared_secret_crc32c);
1663 debug_struct.field(
1664 "verified_ciphertext_crc32c",
1665 &self.verified_ciphertext_crc32c,
1666 );
1667 debug_struct.field("protection_level", &self.protection_level);
1668 if !self._unknown_fields.is_empty() {
1669 debug_struct.field("_unknown_fields", &self._unknown_fields);
1670 }
1671 debug_struct.finish()
1672 }
1673}
1674
1675impl std::fmt::Debug for super::GenerateRandomBytesResponse {
1676 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1677 let mut debug_struct = f.debug_struct("GenerateRandomBytesResponse");
1678 debug_struct.field("data", &self.data);
1679 debug_struct.field("data_crc32c", &self.data_crc32c);
1680 if !self._unknown_fields.is_empty() {
1681 debug_struct.field("_unknown_fields", &self._unknown_fields);
1682 }
1683 debug_struct.finish()
1684 }
1685}
1686
1687impl std::fmt::Debug for super::Digest {
1688 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1689 let mut debug_struct = f.debug_struct("Digest");
1690 debug_struct.field("digest", &self.digest);
1691 if !self._unknown_fields.is_empty() {
1692 debug_struct.field("_unknown_fields", &self._unknown_fields);
1693 }
1694 debug_struct.finish()
1695 }
1696}
1697
1698impl std::fmt::Debug for super::LocationMetadata {
1699 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1700 let mut debug_struct = f.debug_struct("LocationMetadata");
1701 debug_struct.field("hsm_available", &self.hsm_available);
1702 debug_struct.field("ekm_available", &self.ekm_available);
1703 debug_struct.field(
1704 "hsm_single_tenant_available",
1705 &self.hsm_single_tenant_available,
1706 );
1707 if !self._unknown_fields.is_empty() {
1708 debug_struct.field("_unknown_fields", &self._unknown_fields);
1709 }
1710 debug_struct.finish()
1711 }
1712}
1713
1714impl std::fmt::Debug for super::DeleteCryptoKeyMetadata {
1715 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1716 let mut debug_struct = f.debug_struct("DeleteCryptoKeyMetadata");
1717 debug_struct.field("retired_resource", &self.retired_resource);
1718 if !self._unknown_fields.is_empty() {
1719 debug_struct.field("_unknown_fields", &self._unknown_fields);
1720 }
1721 debug_struct.finish()
1722 }
1723}
1724
1725impl std::fmt::Debug for super::DeleteCryptoKeyVersionMetadata {
1726 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1727 let mut debug_struct = f.debug_struct("DeleteCryptoKeyVersionMetadata");
1728 if !self._unknown_fields.is_empty() {
1729 debug_struct.field("_unknown_fields", &self._unknown_fields);
1730 }
1731 debug_struct.finish()
1732 }
1733}