1#[allow(unused_imports)]
18use super::*;
19
20impl std::fmt::Debug for super::CloudSQLBackupRunSource {
21 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
22 let mut debug_struct = f.debug_struct("CloudSQLBackupRunSource");
23 debug_struct.field("project", &self.project);
24 debug_struct.field("instance_id", &self.instance_id);
25 debug_struct.field("backup_run_id", &self.backup_run_id);
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::RestoreFromCloudSQLRequest {
34 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 let mut debug_struct = f.debug_struct("RestoreFromCloudSQLRequest");
36 debug_struct.field("parent", &self.parent);
37 debug_struct.field("cluster_id", &self.cluster_id);
38 debug_struct.field("cluster", &self.cluster);
39 debug_struct.field("source", &self.source);
40 if !self._unknown_fields.is_empty() {
41 debug_struct.field("_unknown_fields", &self._unknown_fields);
42 }
43 debug_struct.finish()
44 }
45}
46
47impl std::fmt::Debug for super::SqlResult {
48 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49 let mut debug_struct = f.debug_struct("SqlResult");
50 debug_struct.field("columns", &self.columns);
51 debug_struct.field("rows", &self.rows);
52 if !self._unknown_fields.is_empty() {
53 debug_struct.field("_unknown_fields", &self._unknown_fields);
54 }
55 debug_struct.finish()
56 }
57}
58
59impl std::fmt::Debug for super::SqlResultColumn {
60 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
61 let mut debug_struct = f.debug_struct("SqlResultColumn");
62 debug_struct.field("name", &self.name);
63 debug_struct.field("r#type", &self.r#type);
64 if !self._unknown_fields.is_empty() {
65 debug_struct.field("_unknown_fields", &self._unknown_fields);
66 }
67 debug_struct.finish()
68 }
69}
70
71impl std::fmt::Debug for super::SqlResultRow {
72 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
73 let mut debug_struct = f.debug_struct("SqlResultRow");
74 debug_struct.field("values", &self.values);
75 if !self._unknown_fields.is_empty() {
76 debug_struct.field("_unknown_fields", &self._unknown_fields);
77 }
78 debug_struct.finish()
79 }
80}
81
82impl std::fmt::Debug for super::SqlResultValue {
83 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
84 let mut debug_struct = f.debug_struct("SqlResultValue");
85 debug_struct.field("value", &self.value);
86 debug_struct.field("null_value", &self.null_value);
87 if !self._unknown_fields.is_empty() {
88 debug_struct.field("_unknown_fields", &self._unknown_fields);
89 }
90 debug_struct.finish()
91 }
92}
93
94impl std::fmt::Debug for super::UserPassword {
95 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
96 let mut debug_struct = f.debug_struct("UserPassword");
97 debug_struct.field("user", &self.user);
98 debug_struct.field("password", &self.password);
99 if !self._unknown_fields.is_empty() {
100 debug_struct.field("_unknown_fields", &self._unknown_fields);
101 }
102 debug_struct.finish()
103 }
104}
105
106impl std::fmt::Debug for super::MigrationSource {
107 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
108 let mut debug_struct = f.debug_struct("MigrationSource");
109 debug_struct.field("host_port", &self.host_port);
110 debug_struct.field("reference_id", &self.reference_id);
111 debug_struct.field("source_type", &self.source_type);
112 if !self._unknown_fields.is_empty() {
113 debug_struct.field("_unknown_fields", &self._unknown_fields);
114 }
115 debug_struct.finish()
116 }
117}
118
119impl std::fmt::Debug for super::EncryptionConfig {
120 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
121 let mut debug_struct = f.debug_struct("EncryptionConfig");
122 debug_struct.field("kms_key_name", &self.kms_key_name);
123 if !self._unknown_fields.is_empty() {
124 debug_struct.field("_unknown_fields", &self._unknown_fields);
125 }
126 debug_struct.finish()
127 }
128}
129
130impl std::fmt::Debug for super::EncryptionInfo {
131 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
132 let mut debug_struct = f.debug_struct("EncryptionInfo");
133 debug_struct.field("encryption_type", &self.encryption_type);
134 debug_struct.field("kms_key_versions", &self.kms_key_versions);
135 if !self._unknown_fields.is_empty() {
136 debug_struct.field("_unknown_fields", &self._unknown_fields);
137 }
138 debug_struct.finish()
139 }
140}
141
142impl std::fmt::Debug for super::SslConfig {
143 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
144 let mut debug_struct = f.debug_struct("SslConfig");
145 debug_struct.field("ssl_mode", &self.ssl_mode);
146 debug_struct.field("ca_source", &self.ca_source);
147 if !self._unknown_fields.is_empty() {
148 debug_struct.field("_unknown_fields", &self._unknown_fields);
149 }
150 debug_struct.finish()
151 }
152}
153
154impl std::fmt::Debug for super::AutomatedBackupPolicy {
155 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156 let mut debug_struct = f.debug_struct("AutomatedBackupPolicy");
157 debug_struct.field("enabled", &self.enabled);
158 debug_struct.field("backup_window", &self.backup_window);
159 debug_struct.field("encryption_config", &self.encryption_config);
160 debug_struct.field("location", &self.location);
161 debug_struct.field("labels", &self.labels);
162 debug_struct.field("schedule", &self.schedule);
163 debug_struct.field("retention", &self.retention);
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::automated_backup_policy::WeeklySchedule {
172 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
173 let mut debug_struct = f.debug_struct("WeeklySchedule");
174 debug_struct.field("start_times", &self.start_times);
175 debug_struct.field("days_of_week", &self.days_of_week);
176 if !self._unknown_fields.is_empty() {
177 debug_struct.field("_unknown_fields", &self._unknown_fields);
178 }
179 debug_struct.finish()
180 }
181}
182
183impl std::fmt::Debug for super::automated_backup_policy::TimeBasedRetention {
184 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185 let mut debug_struct = f.debug_struct("TimeBasedRetention");
186 debug_struct.field("retention_period", &self.retention_period);
187 if !self._unknown_fields.is_empty() {
188 debug_struct.field("_unknown_fields", &self._unknown_fields);
189 }
190 debug_struct.finish()
191 }
192}
193
194impl std::fmt::Debug for super::automated_backup_policy::QuantityBasedRetention {
195 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
196 let mut debug_struct = f.debug_struct("QuantityBasedRetention");
197 debug_struct.field("count", &self.count);
198 if !self._unknown_fields.is_empty() {
199 debug_struct.field("_unknown_fields", &self._unknown_fields);
200 }
201 debug_struct.finish()
202 }
203}
204
205impl std::fmt::Debug for super::ContinuousBackupConfig {
206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
207 let mut debug_struct = f.debug_struct("ContinuousBackupConfig");
208 debug_struct.field("enabled", &self.enabled);
209 debug_struct.field("recovery_window_days", &self.recovery_window_days);
210 debug_struct.field("encryption_config", &self.encryption_config);
211 if !self._unknown_fields.is_empty() {
212 debug_struct.field("_unknown_fields", &self._unknown_fields);
213 }
214 debug_struct.finish()
215 }
216}
217
218impl std::fmt::Debug for super::ContinuousBackupInfo {
219 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220 let mut debug_struct = f.debug_struct("ContinuousBackupInfo");
221 debug_struct.field("encryption_info", &self.encryption_info);
222 debug_struct.field("enabled_time", &self.enabled_time);
223 debug_struct.field("schedule", &self.schedule);
224 debug_struct.field("earliest_restorable_time", &self.earliest_restorable_time);
225 if !self._unknown_fields.is_empty() {
226 debug_struct.field("_unknown_fields", &self._unknown_fields);
227 }
228 debug_struct.finish()
229 }
230}
231
232impl std::fmt::Debug for super::BackupSource {
233 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
234 let mut debug_struct = f.debug_struct("BackupSource");
235 debug_struct.field("backup_uid", &self.backup_uid);
236 debug_struct.field("backup_name", &self.backup_name);
237 if !self._unknown_fields.is_empty() {
238 debug_struct.field("_unknown_fields", &self._unknown_fields);
239 }
240 debug_struct.finish()
241 }
242}
243
244impl std::fmt::Debug for super::ContinuousBackupSource {
245 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
246 let mut debug_struct = f.debug_struct("ContinuousBackupSource");
247 debug_struct.field("cluster", &self.cluster);
248 debug_struct.field("point_in_time", &self.point_in_time);
249 if !self._unknown_fields.is_empty() {
250 debug_struct.field("_unknown_fields", &self._unknown_fields);
251 }
252 debug_struct.finish()
253 }
254}
255
256impl std::fmt::Debug for super::MaintenanceUpdatePolicy {
257 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
258 let mut debug_struct = f.debug_struct("MaintenanceUpdatePolicy");
259 debug_struct.field("maintenance_windows", &self.maintenance_windows);
260 debug_struct.field("deny_maintenance_periods", &self.deny_maintenance_periods);
261 if !self._unknown_fields.is_empty() {
262 debug_struct.field("_unknown_fields", &self._unknown_fields);
263 }
264 debug_struct.finish()
265 }
266}
267
268impl std::fmt::Debug for super::maintenance_update_policy::MaintenanceWindow {
269 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 let mut debug_struct = f.debug_struct("MaintenanceWindow");
271 debug_struct.field("day", &self.day);
272 debug_struct.field("start_time", &self.start_time);
273 if !self._unknown_fields.is_empty() {
274 debug_struct.field("_unknown_fields", &self._unknown_fields);
275 }
276 debug_struct.finish()
277 }
278}
279
280impl std::fmt::Debug for super::maintenance_update_policy::DenyMaintenancePeriod {
281 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
282 let mut debug_struct = f.debug_struct("DenyMaintenancePeriod");
283 debug_struct.field("start_date", &self.start_date);
284 debug_struct.field("end_date", &self.end_date);
285 debug_struct.field("time", &self.time);
286 if !self._unknown_fields.is_empty() {
287 debug_struct.field("_unknown_fields", &self._unknown_fields);
288 }
289 debug_struct.finish()
290 }
291}
292
293impl std::fmt::Debug for super::MaintenanceSchedule {
294 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 let mut debug_struct = f.debug_struct("MaintenanceSchedule");
296 debug_struct.field("start_time", &self.start_time);
297 if !self._unknown_fields.is_empty() {
298 debug_struct.field("_unknown_fields", &self._unknown_fields);
299 }
300 debug_struct.finish()
301 }
302}
303
304impl std::fmt::Debug for super::Cluster {
305 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
306 let mut debug_struct = f.debug_struct("Cluster");
307 debug_struct.field("name", &self.name);
308 debug_struct.field("display_name", &self.display_name);
309 debug_struct.field("uid", &self.uid);
310 debug_struct.field("create_time", &self.create_time);
311 debug_struct.field("update_time", &self.update_time);
312 debug_struct.field("delete_time", &self.delete_time);
313 debug_struct.field("labels", &self.labels);
314 debug_struct.field("state", &self.state);
315 debug_struct.field("cluster_type", &self.cluster_type);
316 debug_struct.field("database_version", &self.database_version);
317 debug_struct.field("network_config", &self.network_config);
318 debug_struct.field("network", &self.network);
319 debug_struct.field("etag", &self.etag);
320 debug_struct.field("annotations", &self.annotations);
321 debug_struct.field("reconciling", &self.reconciling);
322 debug_struct.field("initial_user", &self.initial_user);
323 debug_struct.field("automated_backup_policy", &self.automated_backup_policy);
324 debug_struct.field("ssl_config", &self.ssl_config);
325 debug_struct.field("encryption_config", &self.encryption_config);
326 debug_struct.field("encryption_info", &self.encryption_info);
327 debug_struct.field("continuous_backup_config", &self.continuous_backup_config);
328 debug_struct.field("continuous_backup_info", &self.continuous_backup_info);
329 debug_struct.field("secondary_config", &self.secondary_config);
330 debug_struct.field("primary_config", &self.primary_config);
331 debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
332 debug_struct.field("psc_config", &self.psc_config);
333 debug_struct.field("maintenance_update_policy", &self.maintenance_update_policy);
334 debug_struct.field("maintenance_schedule", &self.maintenance_schedule);
335 debug_struct.field("subscription_type", &self.subscription_type);
336 debug_struct.field("trial_metadata", &self.trial_metadata);
337 debug_struct.field("tags", &self.tags);
338 debug_struct.field("source", &self.source);
339 if !self._unknown_fields.is_empty() {
340 debug_struct.field("_unknown_fields", &self._unknown_fields);
341 }
342 debug_struct.finish()
343 }
344}
345
346impl std::fmt::Debug for super::cluster::NetworkConfig {
347 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
348 let mut debug_struct = f.debug_struct("NetworkConfig");
349 debug_struct.field("network", &self.network);
350 debug_struct.field("allocated_ip_range", &self.allocated_ip_range);
351 if !self._unknown_fields.is_empty() {
352 debug_struct.field("_unknown_fields", &self._unknown_fields);
353 }
354 debug_struct.finish()
355 }
356}
357
358impl std::fmt::Debug for super::cluster::SecondaryConfig {
359 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
360 let mut debug_struct = f.debug_struct("SecondaryConfig");
361 debug_struct.field("primary_cluster_name", &self.primary_cluster_name);
362 if !self._unknown_fields.is_empty() {
363 debug_struct.field("_unknown_fields", &self._unknown_fields);
364 }
365 debug_struct.finish()
366 }
367}
368
369impl std::fmt::Debug for super::cluster::PrimaryConfig {
370 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
371 let mut debug_struct = f.debug_struct("PrimaryConfig");
372 debug_struct.field("secondary_cluster_names", &self.secondary_cluster_names);
373 if !self._unknown_fields.is_empty() {
374 debug_struct.field("_unknown_fields", &self._unknown_fields);
375 }
376 debug_struct.finish()
377 }
378}
379
380impl std::fmt::Debug for super::cluster::PscConfig {
381 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
382 let mut debug_struct = f.debug_struct("PscConfig");
383 debug_struct.field("psc_enabled", &self.psc_enabled);
384 debug_struct.field(
385 "service_owned_project_number",
386 &self.service_owned_project_number,
387 );
388 if !self._unknown_fields.is_empty() {
389 debug_struct.field("_unknown_fields", &self._unknown_fields);
390 }
391 debug_struct.finish()
392 }
393}
394
395impl std::fmt::Debug for super::cluster::TrialMetadata {
396 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
397 let mut debug_struct = f.debug_struct("TrialMetadata");
398 debug_struct.field("start_time", &self.start_time);
399 debug_struct.field("end_time", &self.end_time);
400 debug_struct.field("upgrade_time", &self.upgrade_time);
401 debug_struct.field("grace_end_time", &self.grace_end_time);
402 if !self._unknown_fields.is_empty() {
403 debug_struct.field("_unknown_fields", &self._unknown_fields);
404 }
405 debug_struct.finish()
406 }
407}
408
409impl std::fmt::Debug for super::Instance {
410 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
411 let mut debug_struct = f.debug_struct("Instance");
412 debug_struct.field("name", &self.name);
413 debug_struct.field("display_name", &self.display_name);
414 debug_struct.field("uid", &self.uid);
415 debug_struct.field("create_time", &self.create_time);
416 debug_struct.field("update_time", &self.update_time);
417 debug_struct.field("delete_time", &self.delete_time);
418 debug_struct.field("labels", &self.labels);
419 debug_struct.field("state", &self.state);
420 debug_struct.field("instance_type", &self.instance_type);
421 debug_struct.field("machine_config", &self.machine_config);
422 debug_struct.field("availability_type", &self.availability_type);
423 debug_struct.field("gce_zone", &self.gce_zone);
424 debug_struct.field("database_flags", &self.database_flags);
425 debug_struct.field("writable_node", &self.writable_node);
426 debug_struct.field("nodes", &self.nodes);
427 debug_struct.field("query_insights_config", &self.query_insights_config);
428 debug_struct.field("observability_config", &self.observability_config);
429 debug_struct.field("read_pool_config", &self.read_pool_config);
430 debug_struct.field("ip_address", &self.ip_address);
431 debug_struct.field("public_ip_address", &self.public_ip_address);
432 debug_struct.field("reconciling", &self.reconciling);
433 debug_struct.field("etag", &self.etag);
434 debug_struct.field("annotations", &self.annotations);
435 debug_struct.field("client_connection_config", &self.client_connection_config);
436 debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
437 debug_struct.field("psc_instance_config", &self.psc_instance_config);
438 debug_struct.field("network_config", &self.network_config);
439 debug_struct.field(
440 "outbound_public_ip_addresses",
441 &self.outbound_public_ip_addresses,
442 );
443 debug_struct.field("activation_policy", &self.activation_policy);
444 debug_struct.field("connection_pool_config", &self.connection_pool_config);
445 if !self._unknown_fields.is_empty() {
446 debug_struct.field("_unknown_fields", &self._unknown_fields);
447 }
448 debug_struct.finish()
449 }
450}
451
452impl std::fmt::Debug for super::instance::MachineConfig {
453 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
454 let mut debug_struct = f.debug_struct("MachineConfig");
455 debug_struct.field("cpu_count", &self.cpu_count);
456 debug_struct.field("machine_type", &self.machine_type);
457 if !self._unknown_fields.is_empty() {
458 debug_struct.field("_unknown_fields", &self._unknown_fields);
459 }
460 debug_struct.finish()
461 }
462}
463
464impl std::fmt::Debug for super::instance::Node {
465 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
466 let mut debug_struct = f.debug_struct("Node");
467 debug_struct.field("zone_id", &self.zone_id);
468 debug_struct.field("id", &self.id);
469 debug_struct.field("ip", &self.ip);
470 debug_struct.field("state", &self.state);
471 if !self._unknown_fields.is_empty() {
472 debug_struct.field("_unknown_fields", &self._unknown_fields);
473 }
474 debug_struct.finish()
475 }
476}
477
478impl std::fmt::Debug for super::instance::QueryInsightsInstanceConfig {
479 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
480 let mut debug_struct = f.debug_struct("QueryInsightsInstanceConfig");
481 debug_struct.field("record_application_tags", &self.record_application_tags);
482 debug_struct.field("record_client_address", &self.record_client_address);
483 debug_struct.field("query_string_length", &self.query_string_length);
484 debug_struct.field("query_plans_per_minute", &self.query_plans_per_minute);
485 if !self._unknown_fields.is_empty() {
486 debug_struct.field("_unknown_fields", &self._unknown_fields);
487 }
488 debug_struct.finish()
489 }
490}
491
492impl std::fmt::Debug for super::instance::ObservabilityInstanceConfig {
493 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
494 let mut debug_struct = f.debug_struct("ObservabilityInstanceConfig");
495 debug_struct.field("enabled", &self.enabled);
496 debug_struct.field("preserve_comments", &self.preserve_comments);
497 debug_struct.field("track_wait_events", &self.track_wait_events);
498 debug_struct.field("track_wait_event_types", &self.track_wait_event_types);
499 debug_struct.field("max_query_string_length", &self.max_query_string_length);
500 debug_struct.field("record_application_tags", &self.record_application_tags);
501 debug_struct.field("query_plans_per_minute", &self.query_plans_per_minute);
502 debug_struct.field("track_active_queries", &self.track_active_queries);
503 if !self._unknown_fields.is_empty() {
504 debug_struct.field("_unknown_fields", &self._unknown_fields);
505 }
506 debug_struct.finish()
507 }
508}
509
510impl std::fmt::Debug for super::instance::ReadPoolConfig {
511 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 let mut debug_struct = f.debug_struct("ReadPoolConfig");
513 debug_struct.field("node_count", &self.node_count);
514 if !self._unknown_fields.is_empty() {
515 debug_struct.field("_unknown_fields", &self._unknown_fields);
516 }
517 debug_struct.finish()
518 }
519}
520
521impl std::fmt::Debug for super::instance::ClientConnectionConfig {
522 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
523 let mut debug_struct = f.debug_struct("ClientConnectionConfig");
524 debug_struct.field("require_connectors", &self.require_connectors);
525 debug_struct.field("ssl_config", &self.ssl_config);
526 if !self._unknown_fields.is_empty() {
527 debug_struct.field("_unknown_fields", &self._unknown_fields);
528 }
529 debug_struct.finish()
530 }
531}
532
533impl std::fmt::Debug for super::instance::PscInterfaceConfig {
534 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
535 let mut debug_struct = f.debug_struct("PscInterfaceConfig");
536 debug_struct.field(
537 "network_attachment_resource",
538 &self.network_attachment_resource,
539 );
540 if !self._unknown_fields.is_empty() {
541 debug_struct.field("_unknown_fields", &self._unknown_fields);
542 }
543 debug_struct.finish()
544 }
545}
546
547impl std::fmt::Debug for super::instance::PscAutoConnectionConfig {
548 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
549 let mut debug_struct = f.debug_struct("PscAutoConnectionConfig");
550 debug_struct.field("consumer_project", &self.consumer_project);
551 debug_struct.field("consumer_network", &self.consumer_network);
552 debug_struct.field("ip_address", &self.ip_address);
553 debug_struct.field("status", &self.status);
554 debug_struct.field("consumer_network_status", &self.consumer_network_status);
555 if !self._unknown_fields.is_empty() {
556 debug_struct.field("_unknown_fields", &self._unknown_fields);
557 }
558 debug_struct.finish()
559 }
560}
561
562impl std::fmt::Debug for super::instance::PscInstanceConfig {
563 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
564 let mut debug_struct = f.debug_struct("PscInstanceConfig");
565 debug_struct.field("service_attachment_link", &self.service_attachment_link);
566 debug_struct.field("allowed_consumer_projects", &self.allowed_consumer_projects);
567 debug_struct.field("psc_dns_name", &self.psc_dns_name);
568 debug_struct.field("psc_interface_configs", &self.psc_interface_configs);
569 debug_struct.field("psc_auto_connections", &self.psc_auto_connections);
570 if !self._unknown_fields.is_empty() {
571 debug_struct.field("_unknown_fields", &self._unknown_fields);
572 }
573 debug_struct.finish()
574 }
575}
576
577impl std::fmt::Debug for super::instance::InstanceNetworkConfig {
578 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 let mut debug_struct = f.debug_struct("InstanceNetworkConfig");
580 debug_struct.field(
581 "authorized_external_networks",
582 &self.authorized_external_networks,
583 );
584 debug_struct.field("enable_public_ip", &self.enable_public_ip);
585 debug_struct.field("enable_outbound_public_ip", &self.enable_outbound_public_ip);
586 debug_struct.field("network", &self.network);
587 debug_struct.field(
588 "allocated_ip_range_override",
589 &self.allocated_ip_range_override,
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::instance::instance_network_config::AuthorizedNetwork {
599 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
600 let mut debug_struct = f.debug_struct("AuthorizedNetwork");
601 debug_struct.field("cidr_range", &self.cidr_range);
602 if !self._unknown_fields.is_empty() {
603 debug_struct.field("_unknown_fields", &self._unknown_fields);
604 }
605 debug_struct.finish()
606 }
607}
608
609impl std::fmt::Debug for super::instance::ConnectionPoolConfig {
610 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
611 let mut debug_struct = f.debug_struct("ConnectionPoolConfig");
612 debug_struct.field("enabled", &self.enabled);
613 debug_struct.field("flags", &self.flags);
614 debug_struct.field("pooler_count", &self.pooler_count);
615 if !self._unknown_fields.is_empty() {
616 debug_struct.field("_unknown_fields", &self._unknown_fields);
617 }
618 debug_struct.finish()
619 }
620}
621
622impl std::fmt::Debug for super::ConnectionInfo {
623 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
624 let mut debug_struct = f.debug_struct("ConnectionInfo");
625 debug_struct.field("name", &self.name);
626 debug_struct.field("ip_address", &self.ip_address);
627 debug_struct.field("public_ip_address", &self.public_ip_address);
628 debug_struct.field("instance_uid", &self.instance_uid);
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::Backup {
637 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
638 let mut debug_struct = f.debug_struct("Backup");
639 debug_struct.field("name", &self.name);
640 debug_struct.field("display_name", &self.display_name);
641 debug_struct.field("uid", &self.uid);
642 debug_struct.field("create_time", &self.create_time);
643 debug_struct.field("update_time", &self.update_time);
644 debug_struct.field("delete_time", &self.delete_time);
645 debug_struct.field("create_completion_time", &self.create_completion_time);
646 debug_struct.field("labels", &self.labels);
647 debug_struct.field("state", &self.state);
648 debug_struct.field("r#type", &self.r#type);
649 debug_struct.field("description", &self.description);
650 debug_struct.field("cluster_uid", &self.cluster_uid);
651 debug_struct.field("cluster_name", &self.cluster_name);
652 debug_struct.field("reconciling", &self.reconciling);
653 debug_struct.field("encryption_config", &self.encryption_config);
654 debug_struct.field("encryption_info", &self.encryption_info);
655 debug_struct.field("etag", &self.etag);
656 debug_struct.field("annotations", &self.annotations);
657 debug_struct.field("size_bytes", &self.size_bytes);
658 debug_struct.field("expiry_time", &self.expiry_time);
659 debug_struct.field("expiry_quantity", &self.expiry_quantity);
660 debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
661 debug_struct.field("database_version", &self.database_version);
662 debug_struct.field("tags", &self.tags);
663 if !self._unknown_fields.is_empty() {
664 debug_struct.field("_unknown_fields", &self._unknown_fields);
665 }
666 debug_struct.finish()
667 }
668}
669
670impl std::fmt::Debug for super::backup::QuantityBasedExpiry {
671 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
672 let mut debug_struct = f.debug_struct("QuantityBasedExpiry");
673 debug_struct.field("retention_count", &self.retention_count);
674 debug_struct.field("total_retention_count", &self.total_retention_count);
675 if !self._unknown_fields.is_empty() {
676 debug_struct.field("_unknown_fields", &self._unknown_fields);
677 }
678 debug_struct.finish()
679 }
680}
681
682impl std::fmt::Debug for super::SupportedDatabaseFlag {
683 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
684 let mut debug_struct = f.debug_struct("SupportedDatabaseFlag");
685 debug_struct.field("name", &self.name);
686 debug_struct.field("flag_name", &self.flag_name);
687 debug_struct.field("value_type", &self.value_type);
688 debug_struct.field("accepts_multiple_values", &self.accepts_multiple_values);
689 debug_struct.field("supported_db_versions", &self.supported_db_versions);
690 debug_struct.field("requires_db_restart", &self.requires_db_restart);
691 debug_struct.field("scope", &self.scope);
692 debug_struct.field("restrictions", &self.restrictions);
693 debug_struct.field("recommended_value", &self.recommended_value);
694 if !self._unknown_fields.is_empty() {
695 debug_struct.field("_unknown_fields", &self._unknown_fields);
696 }
697 debug_struct.finish()
698 }
699}
700
701impl std::fmt::Debug for super::supported_database_flag::StringRestrictions {
702 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
703 let mut debug_struct = f.debug_struct("StringRestrictions");
704 debug_struct.field("allowed_values", &self.allowed_values);
705 if !self._unknown_fields.is_empty() {
706 debug_struct.field("_unknown_fields", &self._unknown_fields);
707 }
708 debug_struct.finish()
709 }
710}
711
712impl std::fmt::Debug for super::supported_database_flag::IntegerRestrictions {
713 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
714 let mut debug_struct = f.debug_struct("IntegerRestrictions");
715 debug_struct.field("min_value", &self.min_value);
716 debug_struct.field("max_value", &self.max_value);
717 if !self._unknown_fields.is_empty() {
718 debug_struct.field("_unknown_fields", &self._unknown_fields);
719 }
720 debug_struct.finish()
721 }
722}
723
724impl std::fmt::Debug for super::User {
725 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
726 let mut debug_struct = f.debug_struct("User");
727 debug_struct.field("name", &self.name);
728 debug_struct.field("password", &self.password);
729 debug_struct.field("database_roles", &self.database_roles);
730 debug_struct.field("user_type", &self.user_type);
731 debug_struct.field("keep_extra_roles", &self.keep_extra_roles);
732 if !self._unknown_fields.is_empty() {
733 debug_struct.field("_unknown_fields", &self._unknown_fields);
734 }
735 debug_struct.finish()
736 }
737}
738
739impl std::fmt::Debug for super::Database {
740 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
741 let mut debug_struct = f.debug_struct("Database");
742 debug_struct.field("name", &self.name);
743 debug_struct.field("charset", &self.charset);
744 debug_struct.field("collation", &self.collation);
745 debug_struct.field("character_type", &self.character_type);
746 debug_struct.field("database_template", &self.database_template);
747 debug_struct.field("is_template_database", &self.is_template_database);
748 if !self._unknown_fields.is_empty() {
749 debug_struct.field("_unknown_fields", &self._unknown_fields);
750 }
751 debug_struct.finish()
752 }
753}
754
755impl std::fmt::Debug for super::ListClustersRequest {
756 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
757 let mut debug_struct = f.debug_struct("ListClustersRequest");
758 debug_struct.field("parent", &self.parent);
759 debug_struct.field("page_size", &self.page_size);
760 debug_struct.field("page_token", &self.page_token);
761 debug_struct.field("filter", &self.filter);
762 debug_struct.field("order_by", &self.order_by);
763 if !self._unknown_fields.is_empty() {
764 debug_struct.field("_unknown_fields", &self._unknown_fields);
765 }
766 debug_struct.finish()
767 }
768}
769
770impl std::fmt::Debug for super::ListClustersResponse {
771 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
772 let mut debug_struct = f.debug_struct("ListClustersResponse");
773 debug_struct.field("clusters", &self.clusters);
774 debug_struct.field("next_page_token", &self.next_page_token);
775 debug_struct.field("unreachable", &self.unreachable);
776 if !self._unknown_fields.is_empty() {
777 debug_struct.field("_unknown_fields", &self._unknown_fields);
778 }
779 debug_struct.finish()
780 }
781}
782
783impl std::fmt::Debug for super::GetClusterRequest {
784 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
785 let mut debug_struct = f.debug_struct("GetClusterRequest");
786 debug_struct.field("name", &self.name);
787 debug_struct.field("view", &self.view);
788 if !self._unknown_fields.is_empty() {
789 debug_struct.field("_unknown_fields", &self._unknown_fields);
790 }
791 debug_struct.finish()
792 }
793}
794
795impl std::fmt::Debug for super::CreateSecondaryClusterRequest {
796 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
797 let mut debug_struct = f.debug_struct("CreateSecondaryClusterRequest");
798 debug_struct.field("parent", &self.parent);
799 debug_struct.field("cluster_id", &self.cluster_id);
800 debug_struct.field("cluster", &self.cluster);
801 debug_struct.field("request_id", &self.request_id);
802 debug_struct.field("validate_only", &self.validate_only);
803 if !self._unknown_fields.is_empty() {
804 debug_struct.field("_unknown_fields", &self._unknown_fields);
805 }
806 debug_struct.finish()
807 }
808}
809
810impl std::fmt::Debug for super::CreateClusterRequest {
811 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
812 let mut debug_struct = f.debug_struct("CreateClusterRequest");
813 debug_struct.field("parent", &self.parent);
814 debug_struct.field("cluster_id", &self.cluster_id);
815 debug_struct.field("cluster", &self.cluster);
816 debug_struct.field("request_id", &self.request_id);
817 debug_struct.field("validate_only", &self.validate_only);
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::UpdateClusterRequest {
826 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 let mut debug_struct = f.debug_struct("UpdateClusterRequest");
828 debug_struct.field("update_mask", &self.update_mask);
829 debug_struct.field("cluster", &self.cluster);
830 debug_struct.field("request_id", &self.request_id);
831 debug_struct.field("validate_only", &self.validate_only);
832 debug_struct.field("allow_missing", &self.allow_missing);
833 if !self._unknown_fields.is_empty() {
834 debug_struct.field("_unknown_fields", &self._unknown_fields);
835 }
836 debug_struct.finish()
837 }
838}
839
840impl std::fmt::Debug for super::GcsDestination {
841 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
842 let mut debug_struct = f.debug_struct("GcsDestination");
843 debug_struct.field("uri", &self.uri);
844 if !self._unknown_fields.is_empty() {
845 debug_struct.field("_unknown_fields", &self._unknown_fields);
846 }
847 debug_struct.finish()
848 }
849}
850
851impl std::fmt::Debug for super::ExportClusterRequest {
852 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
853 let mut debug_struct = f.debug_struct("ExportClusterRequest");
854 debug_struct.field("name", &self.name);
855 debug_struct.field("database", &self.database);
856 debug_struct.field("destination", &self.destination);
857 debug_struct.field("export_options", &self.export_options);
858 if !self._unknown_fields.is_empty() {
859 debug_struct.field("_unknown_fields", &self._unknown_fields);
860 }
861 debug_struct.finish()
862 }
863}
864
865impl std::fmt::Debug for super::export_cluster_request::CsvExportOptions {
866 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 let mut debug_struct = f.debug_struct("CsvExportOptions");
868 debug_struct.field("select_query", &self.select_query);
869 debug_struct.field("field_delimiter", &self.field_delimiter);
870 debug_struct.field("quote_character", &self.quote_character);
871 debug_struct.field("escape_character", &self.escape_character);
872 if !self._unknown_fields.is_empty() {
873 debug_struct.field("_unknown_fields", &self._unknown_fields);
874 }
875 debug_struct.finish()
876 }
877}
878
879impl std::fmt::Debug for super::export_cluster_request::SqlExportOptions {
880 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
881 let mut debug_struct = f.debug_struct("SqlExportOptions");
882 debug_struct.field("tables", &self.tables);
883 debug_struct.field("schema_only", &self.schema_only);
884 debug_struct.field("clean_target_objects", &self.clean_target_objects);
885 debug_struct.field("if_exist_target_objects", &self.if_exist_target_objects);
886 if !self._unknown_fields.is_empty() {
887 debug_struct.field("_unknown_fields", &self._unknown_fields);
888 }
889 debug_struct.finish()
890 }
891}
892
893impl std::fmt::Debug for super::ExportClusterResponse {
894 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
895 let mut debug_struct = f.debug_struct("ExportClusterResponse");
896 debug_struct.field("destination", &self.destination);
897 if !self._unknown_fields.is_empty() {
898 debug_struct.field("_unknown_fields", &self._unknown_fields);
899 }
900 debug_struct.finish()
901 }
902}
903
904impl std::fmt::Debug for super::ImportClusterRequest {
905 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
906 let mut debug_struct = f.debug_struct("ImportClusterRequest");
907 debug_struct.field("name", &self.name);
908 debug_struct.field("gcs_uri", &self.gcs_uri);
909 debug_struct.field("database", &self.database);
910 debug_struct.field("user", &self.user);
911 debug_struct.field("import_options", &self.import_options);
912 if !self._unknown_fields.is_empty() {
913 debug_struct.field("_unknown_fields", &self._unknown_fields);
914 }
915 debug_struct.finish()
916 }
917}
918
919impl std::fmt::Debug for super::import_cluster_request::SqlImportOptions {
920 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
921 let mut debug_struct = f.debug_struct("SqlImportOptions");
922 if !self._unknown_fields.is_empty() {
923 debug_struct.field("_unknown_fields", &self._unknown_fields);
924 }
925 debug_struct.finish()
926 }
927}
928
929impl std::fmt::Debug for super::import_cluster_request::CsvImportOptions {
930 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
931 let mut debug_struct = f.debug_struct("CsvImportOptions");
932 debug_struct.field("table", &self.table);
933 debug_struct.field("columns", &self.columns);
934 debug_struct.field("field_delimiter", &self.field_delimiter);
935 debug_struct.field("quote_character", &self.quote_character);
936 debug_struct.field("escape_character", &self.escape_character);
937 if !self._unknown_fields.is_empty() {
938 debug_struct.field("_unknown_fields", &self._unknown_fields);
939 }
940 debug_struct.finish()
941 }
942}
943
944impl std::fmt::Debug for super::ImportClusterResponse {
945 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
946 let mut debug_struct = f.debug_struct("ImportClusterResponse");
947 debug_struct.field("bytes_downloaded", &self.bytes_downloaded);
948 if !self._unknown_fields.is_empty() {
949 debug_struct.field("_unknown_fields", &self._unknown_fields);
950 }
951 debug_struct.finish()
952 }
953}
954
955impl std::fmt::Debug for super::UpgradeClusterRequest {
956 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
957 let mut debug_struct = f.debug_struct("UpgradeClusterRequest");
958 debug_struct.field("name", &self.name);
959 debug_struct.field("version", &self.version);
960 debug_struct.field("request_id", &self.request_id);
961 debug_struct.field("validate_only", &self.validate_only);
962 debug_struct.field("etag", &self.etag);
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::UpgradeClusterResponse {
971 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
972 let mut debug_struct = f.debug_struct("UpgradeClusterResponse");
973 debug_struct.field("status", &self.status);
974 debug_struct.field("message", &self.message);
975 debug_struct.field("cluster_upgrade_details", &self.cluster_upgrade_details);
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::upgrade_cluster_response::StageInfo {
984 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
985 let mut debug_struct = f.debug_struct("StageInfo");
986 debug_struct.field("stage", &self.stage);
987 debug_struct.field("status", &self.status);
988 debug_struct.field("logs_url", &self.logs_url);
989 if !self._unknown_fields.is_empty() {
990 debug_struct.field("_unknown_fields", &self._unknown_fields);
991 }
992 debug_struct.finish()
993 }
994}
995
996impl std::fmt::Debug for super::upgrade_cluster_response::InstanceUpgradeDetails {
997 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
998 let mut debug_struct = f.debug_struct("InstanceUpgradeDetails");
999 debug_struct.field("name", &self.name);
1000 debug_struct.field("upgrade_status", &self.upgrade_status);
1001 debug_struct.field("instance_type", &self.instance_type);
1002 if !self._unknown_fields.is_empty() {
1003 debug_struct.field("_unknown_fields", &self._unknown_fields);
1004 }
1005 debug_struct.finish()
1006 }
1007}
1008
1009impl std::fmt::Debug for super::upgrade_cluster_response::ClusterUpgradeDetails {
1010 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1011 let mut debug_struct = f.debug_struct("ClusterUpgradeDetails");
1012 debug_struct.field("name", &self.name);
1013 debug_struct.field("upgrade_status", &self.upgrade_status);
1014 debug_struct.field("cluster_type", &self.cluster_type);
1015 debug_struct.field("database_version", &self.database_version);
1016 debug_struct.field("stage_info", &self.stage_info);
1017 debug_struct.field("instance_upgrade_details", &self.instance_upgrade_details);
1018 if !self._unknown_fields.is_empty() {
1019 debug_struct.field("_unknown_fields", &self._unknown_fields);
1020 }
1021 debug_struct.finish()
1022 }
1023}
1024
1025impl std::fmt::Debug for super::DeleteClusterRequest {
1026 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1027 let mut debug_struct = f.debug_struct("DeleteClusterRequest");
1028 debug_struct.field("name", &self.name);
1029 debug_struct.field("request_id", &self.request_id);
1030 debug_struct.field("etag", &self.etag);
1031 debug_struct.field("validate_only", &self.validate_only);
1032 debug_struct.field("force", &self.force);
1033 if !self._unknown_fields.is_empty() {
1034 debug_struct.field("_unknown_fields", &self._unknown_fields);
1035 }
1036 debug_struct.finish()
1037 }
1038}
1039
1040impl std::fmt::Debug for super::SwitchoverClusterRequest {
1041 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1042 let mut debug_struct = f.debug_struct("SwitchoverClusterRequest");
1043 debug_struct.field("name", &self.name);
1044 debug_struct.field("request_id", &self.request_id);
1045 debug_struct.field("validate_only", &self.validate_only);
1046 if !self._unknown_fields.is_empty() {
1047 debug_struct.field("_unknown_fields", &self._unknown_fields);
1048 }
1049 debug_struct.finish()
1050 }
1051}
1052
1053impl std::fmt::Debug for super::PromoteClusterRequest {
1054 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1055 let mut debug_struct = f.debug_struct("PromoteClusterRequest");
1056 debug_struct.field("name", &self.name);
1057 debug_struct.field("request_id", &self.request_id);
1058 debug_struct.field("etag", &self.etag);
1059 debug_struct.field("validate_only", &self.validate_only);
1060 if !self._unknown_fields.is_empty() {
1061 debug_struct.field("_unknown_fields", &self._unknown_fields);
1062 }
1063 debug_struct.finish()
1064 }
1065}
1066
1067impl std::fmt::Debug for super::RestoreClusterRequest {
1068 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1069 let mut debug_struct = f.debug_struct("RestoreClusterRequest");
1070 debug_struct.field("parent", &self.parent);
1071 debug_struct.field("cluster_id", &self.cluster_id);
1072 debug_struct.field("cluster", &self.cluster);
1073 debug_struct.field("request_id", &self.request_id);
1074 debug_struct.field("validate_only", &self.validate_only);
1075 debug_struct.field("source", &self.source);
1076 if !self._unknown_fields.is_empty() {
1077 debug_struct.field("_unknown_fields", &self._unknown_fields);
1078 }
1079 debug_struct.finish()
1080 }
1081}
1082
1083impl std::fmt::Debug for super::ListInstancesRequest {
1084 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1085 let mut debug_struct = f.debug_struct("ListInstancesRequest");
1086 debug_struct.field("parent", &self.parent);
1087 debug_struct.field("page_size", &self.page_size);
1088 debug_struct.field("page_token", &self.page_token);
1089 debug_struct.field("filter", &self.filter);
1090 debug_struct.field("order_by", &self.order_by);
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::ListInstancesResponse {
1099 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1100 let mut debug_struct = f.debug_struct("ListInstancesResponse");
1101 debug_struct.field("instances", &self.instances);
1102 debug_struct.field("next_page_token", &self.next_page_token);
1103 debug_struct.field("unreachable", &self.unreachable);
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::GetInstanceRequest {
1112 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1113 let mut debug_struct = f.debug_struct("GetInstanceRequest");
1114 debug_struct.field("name", &self.name);
1115 debug_struct.field("view", &self.view);
1116 if !self._unknown_fields.is_empty() {
1117 debug_struct.field("_unknown_fields", &self._unknown_fields);
1118 }
1119 debug_struct.finish()
1120 }
1121}
1122
1123impl std::fmt::Debug for super::CreateInstanceRequest {
1124 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1125 let mut debug_struct = f.debug_struct("CreateInstanceRequest");
1126 debug_struct.field("parent", &self.parent);
1127 debug_struct.field("instance_id", &self.instance_id);
1128 debug_struct.field("instance", &self.instance);
1129 debug_struct.field("request_id", &self.request_id);
1130 debug_struct.field("validate_only", &self.validate_only);
1131 if !self._unknown_fields.is_empty() {
1132 debug_struct.field("_unknown_fields", &self._unknown_fields);
1133 }
1134 debug_struct.finish()
1135 }
1136}
1137
1138impl std::fmt::Debug for super::CreateSecondaryInstanceRequest {
1139 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1140 let mut debug_struct = f.debug_struct("CreateSecondaryInstanceRequest");
1141 debug_struct.field("parent", &self.parent);
1142 debug_struct.field("instance_id", &self.instance_id);
1143 debug_struct.field("instance", &self.instance);
1144 debug_struct.field("request_id", &self.request_id);
1145 debug_struct.field("validate_only", &self.validate_only);
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::CreateInstanceRequests {
1154 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1155 let mut debug_struct = f.debug_struct("CreateInstanceRequests");
1156 debug_struct.field("create_instance_requests", &self.create_instance_requests);
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::BatchCreateInstancesRequest {
1165 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1166 let mut debug_struct = f.debug_struct("BatchCreateInstancesRequest");
1167 debug_struct.field("parent", &self.parent);
1168 debug_struct.field("requests", &self.requests);
1169 debug_struct.field("request_id", &self.request_id);
1170 if !self._unknown_fields.is_empty() {
1171 debug_struct.field("_unknown_fields", &self._unknown_fields);
1172 }
1173 debug_struct.finish()
1174 }
1175}
1176
1177impl std::fmt::Debug for super::BatchCreateInstancesResponse {
1178 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1179 let mut debug_struct = f.debug_struct("BatchCreateInstancesResponse");
1180 debug_struct.field("instances", &self.instances);
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::BatchCreateInstancesMetadata {
1189 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1190 let mut debug_struct = f.debug_struct("BatchCreateInstancesMetadata");
1191 debug_struct.field("instance_targets", &self.instance_targets);
1192 debug_struct.field("instance_statuses", &self.instance_statuses);
1193 if !self._unknown_fields.is_empty() {
1194 debug_struct.field("_unknown_fields", &self._unknown_fields);
1195 }
1196 debug_struct.finish()
1197 }
1198}
1199
1200impl std::fmt::Debug for super::BatchCreateInstanceStatus {
1201 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1202 let mut debug_struct = f.debug_struct("BatchCreateInstanceStatus");
1203 debug_struct.field("state", &self.state);
1204 debug_struct.field("error_msg", &self.error_msg);
1205 debug_struct.field("error", &self.error);
1206 debug_struct.field("r#type", &self.r#type);
1207 if !self._unknown_fields.is_empty() {
1208 debug_struct.field("_unknown_fields", &self._unknown_fields);
1209 }
1210 debug_struct.finish()
1211 }
1212}
1213
1214impl std::fmt::Debug for super::UpdateInstanceRequest {
1215 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1216 let mut debug_struct = f.debug_struct("UpdateInstanceRequest");
1217 debug_struct.field("update_mask", &self.update_mask);
1218 debug_struct.field("instance", &self.instance);
1219 debug_struct.field("request_id", &self.request_id);
1220 debug_struct.field("validate_only", &self.validate_only);
1221 debug_struct.field("allow_missing", &self.allow_missing);
1222 if !self._unknown_fields.is_empty() {
1223 debug_struct.field("_unknown_fields", &self._unknown_fields);
1224 }
1225 debug_struct.finish()
1226 }
1227}
1228
1229impl std::fmt::Debug for super::DeleteInstanceRequest {
1230 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1231 let mut debug_struct = f.debug_struct("DeleteInstanceRequest");
1232 debug_struct.field("name", &self.name);
1233 debug_struct.field("request_id", &self.request_id);
1234 debug_struct.field("etag", &self.etag);
1235 debug_struct.field("validate_only", &self.validate_only);
1236 if !self._unknown_fields.is_empty() {
1237 debug_struct.field("_unknown_fields", &self._unknown_fields);
1238 }
1239 debug_struct.finish()
1240 }
1241}
1242
1243impl std::fmt::Debug for super::FailoverInstanceRequest {
1244 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1245 let mut debug_struct = f.debug_struct("FailoverInstanceRequest");
1246 debug_struct.field("name", &self.name);
1247 debug_struct.field("request_id", &self.request_id);
1248 debug_struct.field("validate_only", &self.validate_only);
1249 if !self._unknown_fields.is_empty() {
1250 debug_struct.field("_unknown_fields", &self._unknown_fields);
1251 }
1252 debug_struct.finish()
1253 }
1254}
1255
1256impl std::fmt::Debug for super::InjectFaultRequest {
1257 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1258 let mut debug_struct = f.debug_struct("InjectFaultRequest");
1259 debug_struct.field("fault_type", &self.fault_type);
1260 debug_struct.field("name", &self.name);
1261 debug_struct.field("request_id", &self.request_id);
1262 debug_struct.field("validate_only", &self.validate_only);
1263 if !self._unknown_fields.is_empty() {
1264 debug_struct.field("_unknown_fields", &self._unknown_fields);
1265 }
1266 debug_struct.finish()
1267 }
1268}
1269
1270impl std::fmt::Debug for super::RestartInstanceRequest {
1271 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1272 let mut debug_struct = f.debug_struct("RestartInstanceRequest");
1273 debug_struct.field("name", &self.name);
1274 debug_struct.field("request_id", &self.request_id);
1275 debug_struct.field("validate_only", &self.validate_only);
1276 debug_struct.field("node_ids", &self.node_ids);
1277 if !self._unknown_fields.is_empty() {
1278 debug_struct.field("_unknown_fields", &self._unknown_fields);
1279 }
1280 debug_struct.finish()
1281 }
1282}
1283
1284impl std::fmt::Debug for super::ExecuteSqlRequest {
1285 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1286 let mut debug_struct = f.debug_struct("ExecuteSqlRequest");
1287 debug_struct.field("instance", &self.instance);
1288 debug_struct.field("database", &self.database);
1289 debug_struct.field("user", &self.user);
1290 debug_struct.field("sql_statement", &self.sql_statement);
1291 debug_struct.field("validate_only", &self.validate_only);
1292 debug_struct.field("user_credential", &self.user_credential);
1293 if !self._unknown_fields.is_empty() {
1294 debug_struct.field("_unknown_fields", &self._unknown_fields);
1295 }
1296 debug_struct.finish()
1297 }
1298}
1299
1300impl std::fmt::Debug for super::ExecuteSqlResponse {
1301 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1302 let mut debug_struct = f.debug_struct("ExecuteSqlResponse");
1303 debug_struct.field("sql_results", &self.sql_results);
1304 debug_struct.field("metadata", &self.metadata);
1305 if !self._unknown_fields.is_empty() {
1306 debug_struct.field("_unknown_fields", &self._unknown_fields);
1307 }
1308 debug_struct.finish()
1309 }
1310}
1311
1312impl std::fmt::Debug for super::ExecuteSqlMetadata {
1313 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1314 let mut debug_struct = f.debug_struct("ExecuteSqlMetadata");
1315 debug_struct.field("message", &self.message);
1316 debug_struct.field("partial_result", &self.partial_result);
1317 debug_struct.field(
1318 "sql_statement_execution_duration",
1319 &self.sql_statement_execution_duration,
1320 );
1321 debug_struct.field("status", &self.status);
1322 if !self._unknown_fields.is_empty() {
1323 debug_struct.field("_unknown_fields", &self._unknown_fields);
1324 }
1325 debug_struct.finish()
1326 }
1327}
1328
1329impl std::fmt::Debug for super::ListBackupsRequest {
1330 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1331 let mut debug_struct = f.debug_struct("ListBackupsRequest");
1332 debug_struct.field("parent", &self.parent);
1333 debug_struct.field("page_size", &self.page_size);
1334 debug_struct.field("page_token", &self.page_token);
1335 debug_struct.field("filter", &self.filter);
1336 debug_struct.field("order_by", &self.order_by);
1337 if !self._unknown_fields.is_empty() {
1338 debug_struct.field("_unknown_fields", &self._unknown_fields);
1339 }
1340 debug_struct.finish()
1341 }
1342}
1343
1344impl std::fmt::Debug for super::ListBackupsResponse {
1345 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1346 let mut debug_struct = f.debug_struct("ListBackupsResponse");
1347 debug_struct.field("backups", &self.backups);
1348 debug_struct.field("next_page_token", &self.next_page_token);
1349 debug_struct.field("unreachable", &self.unreachable);
1350 if !self._unknown_fields.is_empty() {
1351 debug_struct.field("_unknown_fields", &self._unknown_fields);
1352 }
1353 debug_struct.finish()
1354 }
1355}
1356
1357impl std::fmt::Debug for super::GetBackupRequest {
1358 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1359 let mut debug_struct = f.debug_struct("GetBackupRequest");
1360 debug_struct.field("name", &self.name);
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::CreateBackupRequest {
1369 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1370 let mut debug_struct = f.debug_struct("CreateBackupRequest");
1371 debug_struct.field("parent", &self.parent);
1372 debug_struct.field("backup_id", &self.backup_id);
1373 debug_struct.field("backup", &self.backup);
1374 debug_struct.field("request_id", &self.request_id);
1375 debug_struct.field("validate_only", &self.validate_only);
1376 if !self._unknown_fields.is_empty() {
1377 debug_struct.field("_unknown_fields", &self._unknown_fields);
1378 }
1379 debug_struct.finish()
1380 }
1381}
1382
1383impl std::fmt::Debug for super::UpdateBackupRequest {
1384 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1385 let mut debug_struct = f.debug_struct("UpdateBackupRequest");
1386 debug_struct.field("update_mask", &self.update_mask);
1387 debug_struct.field("backup", &self.backup);
1388 debug_struct.field("request_id", &self.request_id);
1389 debug_struct.field("validate_only", &self.validate_only);
1390 debug_struct.field("allow_missing", &self.allow_missing);
1391 if !self._unknown_fields.is_empty() {
1392 debug_struct.field("_unknown_fields", &self._unknown_fields);
1393 }
1394 debug_struct.finish()
1395 }
1396}
1397
1398impl std::fmt::Debug for super::DeleteBackupRequest {
1399 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1400 let mut debug_struct = f.debug_struct("DeleteBackupRequest");
1401 debug_struct.field("name", &self.name);
1402 debug_struct.field("request_id", &self.request_id);
1403 debug_struct.field("validate_only", &self.validate_only);
1404 debug_struct.field("etag", &self.etag);
1405 if !self._unknown_fields.is_empty() {
1406 debug_struct.field("_unknown_fields", &self._unknown_fields);
1407 }
1408 debug_struct.finish()
1409 }
1410}
1411
1412impl std::fmt::Debug for super::ListSupportedDatabaseFlagsRequest {
1413 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1414 let mut debug_struct = f.debug_struct("ListSupportedDatabaseFlagsRequest");
1415 debug_struct.field("parent", &self.parent);
1416 debug_struct.field("page_size", &self.page_size);
1417 debug_struct.field("page_token", &self.page_token);
1418 debug_struct.field("scope", &self.scope);
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::ListSupportedDatabaseFlagsResponse {
1427 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1428 let mut debug_struct = f.debug_struct("ListSupportedDatabaseFlagsResponse");
1429 debug_struct.field("supported_database_flags", &self.supported_database_flags);
1430 debug_struct.field("next_page_token", &self.next_page_token);
1431 if !self._unknown_fields.is_empty() {
1432 debug_struct.field("_unknown_fields", &self._unknown_fields);
1433 }
1434 debug_struct.finish()
1435 }
1436}
1437
1438impl std::fmt::Debug for super::GenerateClientCertificateRequest {
1439 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1440 let mut debug_struct = f.debug_struct("GenerateClientCertificateRequest");
1441 debug_struct.field("parent", &self.parent);
1442 debug_struct.field("request_id", &self.request_id);
1443 debug_struct.field("cert_duration", &self.cert_duration);
1444 debug_struct.field("public_key", &self.public_key);
1445 debug_struct.field("use_metadata_exchange", &self.use_metadata_exchange);
1446 if !self._unknown_fields.is_empty() {
1447 debug_struct.field("_unknown_fields", &self._unknown_fields);
1448 }
1449 debug_struct.finish()
1450 }
1451}
1452
1453impl std::fmt::Debug for super::GenerateClientCertificateResponse {
1454 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1455 let mut debug_struct = f.debug_struct("GenerateClientCertificateResponse");
1456 debug_struct.field("pem_certificate_chain", &self.pem_certificate_chain);
1457 debug_struct.field("ca_cert", &self.ca_cert);
1458 if !self._unknown_fields.is_empty() {
1459 debug_struct.field("_unknown_fields", &self._unknown_fields);
1460 }
1461 debug_struct.finish()
1462 }
1463}
1464
1465impl std::fmt::Debug for super::GetConnectionInfoRequest {
1466 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1467 let mut debug_struct = f.debug_struct("GetConnectionInfoRequest");
1468 debug_struct.field("parent", &self.parent);
1469 debug_struct.field("request_id", &self.request_id);
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::OperationMetadata {
1478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 let mut debug_struct = f.debug_struct("OperationMetadata");
1480 debug_struct.field("create_time", &self.create_time);
1481 debug_struct.field("end_time", &self.end_time);
1482 debug_struct.field("target", &self.target);
1483 debug_struct.field("verb", &self.verb);
1484 debug_struct.field("status_message", &self.status_message);
1485 debug_struct.field("requested_cancellation", &self.requested_cancellation);
1486 debug_struct.field("api_version", &self.api_version);
1487 debug_struct.field("request_specific", &self.request_specific);
1488 if !self._unknown_fields.is_empty() {
1489 debug_struct.field("_unknown_fields", &self._unknown_fields);
1490 }
1491 debug_struct.finish()
1492 }
1493}
1494
1495impl std::fmt::Debug for super::UpgradeClusterStatus {
1496 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1497 let mut debug_struct = f.debug_struct("UpgradeClusterStatus");
1498 debug_struct.field("state", &self.state);
1499 debug_struct.field("cancellable", &self.cancellable);
1500 debug_struct.field("source_version", &self.source_version);
1501 debug_struct.field("target_version", &self.target_version);
1502 debug_struct.field("stages", &self.stages);
1503 if !self._unknown_fields.is_empty() {
1504 debug_struct.field("_unknown_fields", &self._unknown_fields);
1505 }
1506 debug_struct.finish()
1507 }
1508}
1509
1510impl std::fmt::Debug for super::upgrade_cluster_status::StageStatus {
1511 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1512 let mut debug_struct = f.debug_struct("StageStatus");
1513 debug_struct.field("stage", &self.stage);
1514 debug_struct.field("state", &self.state);
1515 debug_struct.field("schedule", &self.schedule);
1516 debug_struct.field("stage_specific_status", &self.stage_specific_status);
1517 if !self._unknown_fields.is_empty() {
1518 debug_struct.field("_unknown_fields", &self._unknown_fields);
1519 }
1520 debug_struct.finish()
1521 }
1522}
1523
1524impl std::fmt::Debug for super::upgrade_cluster_status::stage_status::StageSchedule {
1525 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1526 let mut debug_struct = f.debug_struct("StageSchedule");
1527 debug_struct.field("estimated_start_time", &self.estimated_start_time);
1528 debug_struct.field("actual_start_time", &self.actual_start_time);
1529 debug_struct.field("estimated_end_time", &self.estimated_end_time);
1530 debug_struct.field("actual_end_time", &self.actual_end_time);
1531 if !self._unknown_fields.is_empty() {
1532 debug_struct.field("_unknown_fields", &self._unknown_fields);
1533 }
1534 debug_struct.finish()
1535 }
1536}
1537
1538impl std::fmt::Debug for super::upgrade_cluster_status::ReadPoolInstancesUpgradeStageStatus {
1539 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 let mut debug_struct = f.debug_struct("ReadPoolInstancesUpgradeStageStatus");
1541 debug_struct.field("upgrade_stats", &self.upgrade_stats);
1542 if !self._unknown_fields.is_empty() {
1543 debug_struct.field("_unknown_fields", &self._unknown_fields);
1544 }
1545 debug_struct.finish()
1546 }
1547}
1548
1549impl std::fmt::Debug
1550 for super::upgrade_cluster_status::read_pool_instances_upgrade_stage_status::Stats
1551{
1552 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1553 let mut debug_struct = f.debug_struct("Stats");
1554 debug_struct.field("not_started", &self.not_started);
1555 debug_struct.field("ongoing", &self.ongoing);
1556 debug_struct.field("success", &self.success);
1557 debug_struct.field("failed", &self.failed);
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::ListUsersRequest {
1566 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1567 let mut debug_struct = f.debug_struct("ListUsersRequest");
1568 debug_struct.field("parent", &self.parent);
1569 debug_struct.field("page_size", &self.page_size);
1570 debug_struct.field("page_token", &self.page_token);
1571 debug_struct.field("filter", &self.filter);
1572 debug_struct.field("order_by", &self.order_by);
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::ListUsersResponse {
1581 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1582 let mut debug_struct = f.debug_struct("ListUsersResponse");
1583 debug_struct.field("users", &self.users);
1584 debug_struct.field("next_page_token", &self.next_page_token);
1585 debug_struct.field("unreachable", &self.unreachable);
1586 if !self._unknown_fields.is_empty() {
1587 debug_struct.field("_unknown_fields", &self._unknown_fields);
1588 }
1589 debug_struct.finish()
1590 }
1591}
1592
1593impl std::fmt::Debug for super::GetUserRequest {
1594 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1595 let mut debug_struct = f.debug_struct("GetUserRequest");
1596 debug_struct.field("name", &self.name);
1597 if !self._unknown_fields.is_empty() {
1598 debug_struct.field("_unknown_fields", &self._unknown_fields);
1599 }
1600 debug_struct.finish()
1601 }
1602}
1603
1604impl std::fmt::Debug for super::CreateUserRequest {
1605 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1606 let mut debug_struct = f.debug_struct("CreateUserRequest");
1607 debug_struct.field("parent", &self.parent);
1608 debug_struct.field("user_id", &self.user_id);
1609 debug_struct.field("user", &self.user);
1610 debug_struct.field("request_id", &self.request_id);
1611 debug_struct.field("validate_only", &self.validate_only);
1612 if !self._unknown_fields.is_empty() {
1613 debug_struct.field("_unknown_fields", &self._unknown_fields);
1614 }
1615 debug_struct.finish()
1616 }
1617}
1618
1619impl std::fmt::Debug for super::UpdateUserRequest {
1620 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1621 let mut debug_struct = f.debug_struct("UpdateUserRequest");
1622 debug_struct.field("update_mask", &self.update_mask);
1623 debug_struct.field("user", &self.user);
1624 debug_struct.field("request_id", &self.request_id);
1625 debug_struct.field("validate_only", &self.validate_only);
1626 debug_struct.field("allow_missing", &self.allow_missing);
1627 if !self._unknown_fields.is_empty() {
1628 debug_struct.field("_unknown_fields", &self._unknown_fields);
1629 }
1630 debug_struct.finish()
1631 }
1632}
1633
1634impl std::fmt::Debug for super::DeleteUserRequest {
1635 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1636 let mut debug_struct = f.debug_struct("DeleteUserRequest");
1637 debug_struct.field("name", &self.name);
1638 debug_struct.field("request_id", &self.request_id);
1639 debug_struct.field("validate_only", &self.validate_only);
1640 if !self._unknown_fields.is_empty() {
1641 debug_struct.field("_unknown_fields", &self._unknown_fields);
1642 }
1643 debug_struct.finish()
1644 }
1645}
1646
1647impl std::fmt::Debug for super::ListDatabasesRequest {
1648 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1649 let mut debug_struct = f.debug_struct("ListDatabasesRequest");
1650 debug_struct.field("parent", &self.parent);
1651 debug_struct.field("page_size", &self.page_size);
1652 debug_struct.field("page_token", &self.page_token);
1653 debug_struct.field("filter", &self.filter);
1654 if !self._unknown_fields.is_empty() {
1655 debug_struct.field("_unknown_fields", &self._unknown_fields);
1656 }
1657 debug_struct.finish()
1658 }
1659}
1660
1661impl std::fmt::Debug for super::ListDatabasesResponse {
1662 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1663 let mut debug_struct = f.debug_struct("ListDatabasesResponse");
1664 debug_struct.field("databases", &self.databases);
1665 debug_struct.field("next_page_token", &self.next_page_token);
1666 if !self._unknown_fields.is_empty() {
1667 debug_struct.field("_unknown_fields", &self._unknown_fields);
1668 }
1669 debug_struct.finish()
1670 }
1671}