1#[allow(unused_imports)]
18use super::*;
19
20impl std::fmt::Debug for super::BigQueryConnectionSpec {
21 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
22 let mut debug_struct = f.debug_struct("BigQueryConnectionSpec");
23 debug_struct.field("connection_type", &self.connection_type);
24 debug_struct.field("has_credential", &self.has_credential);
25 debug_struct.field("connection_spec", &self.connection_spec);
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::CloudSqlBigQueryConnectionSpec {
34 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 let mut debug_struct = f.debug_struct("CloudSqlBigQueryConnectionSpec");
36 debug_struct.field("instance_id", &self.instance_id);
37 debug_struct.field("database", &self.database);
38 debug_struct.field("r#type", &self.r#type);
39 if !self._unknown_fields.is_empty() {
40 debug_struct.field("_unknown_fields", &self._unknown_fields);
41 }
42 debug_struct.finish()
43 }
44}
45
46impl std::fmt::Debug for super::BigQueryRoutineSpec {
47 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 let mut debug_struct = f.debug_struct("BigQueryRoutineSpec");
49 debug_struct.field("imported_libraries", &self.imported_libraries);
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::PersonalDetails {
58 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
59 let mut debug_struct = f.debug_struct("PersonalDetails");
60 debug_struct.field("starred", &self.starred);
61 debug_struct.field("star_time", &self.star_time);
62 if !self._unknown_fields.is_empty() {
63 debug_struct.field("_unknown_fields", &self._unknown_fields);
64 }
65 debug_struct.finish()
66 }
67}
68
69impl std::fmt::Debug for super::DataSource {
70 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
71 let mut debug_struct = f.debug_struct("DataSource");
72 debug_struct.field("service", &self.service);
73 debug_struct.field("resource", &self.resource);
74 debug_struct.field("source_entry", &self.source_entry);
75 debug_struct.field("properties", &self.properties);
76 if !self._unknown_fields.is_empty() {
77 debug_struct.field("_unknown_fields", &self._unknown_fields);
78 }
79 debug_struct.finish()
80 }
81}
82
83impl std::fmt::Debug for super::StorageProperties {
84 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
85 let mut debug_struct = f.debug_struct("StorageProperties");
86 debug_struct.field("file_pattern", &self.file_pattern);
87 debug_struct.field("file_type", &self.file_type);
88 if !self._unknown_fields.is_empty() {
89 debug_struct.field("_unknown_fields", &self._unknown_fields);
90 }
91 debug_struct.finish()
92 }
93}
94
95impl std::fmt::Debug for super::SearchCatalogRequest {
96 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
97 let mut debug_struct = f.debug_struct("SearchCatalogRequest");
98 debug_struct.field("scope", &self.scope);
99 debug_struct.field("query", &self.query);
100 debug_struct.field("page_size", &self.page_size);
101 debug_struct.field("page_token", &self.page_token);
102 debug_struct.field("order_by", &self.order_by);
103 debug_struct.field("admin_search", &self.admin_search);
104 if !self._unknown_fields.is_empty() {
105 debug_struct.field("_unknown_fields", &self._unknown_fields);
106 }
107 debug_struct.finish()
108 }
109}
110
111impl std::fmt::Debug for super::search_catalog_request::Scope {
112 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
113 let mut debug_struct = f.debug_struct("Scope");
114 debug_struct.field("include_org_ids", &self.include_org_ids);
115 debug_struct.field("include_project_ids", &self.include_project_ids);
116 debug_struct.field(
117 "include_gcp_public_datasets",
118 &self.include_gcp_public_datasets,
119 );
120 debug_struct.field("restricted_locations", &self.restricted_locations);
121 debug_struct.field("starred_only", &self.starred_only);
122 debug_struct.field(
123 "include_public_tag_templates",
124 &self.include_public_tag_templates,
125 );
126 if !self._unknown_fields.is_empty() {
127 debug_struct.field("_unknown_fields", &self._unknown_fields);
128 }
129 debug_struct.finish()
130 }
131}
132
133impl std::fmt::Debug for super::SearchCatalogResponse {
134 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
135 let mut debug_struct = f.debug_struct("SearchCatalogResponse");
136 debug_struct.field("results", &self.results);
137 debug_struct.field("total_size", &self.total_size);
138 debug_struct.field("next_page_token", &self.next_page_token);
139 debug_struct.field("unreachable", &self.unreachable);
140 if !self._unknown_fields.is_empty() {
141 debug_struct.field("_unknown_fields", &self._unknown_fields);
142 }
143 debug_struct.finish()
144 }
145}
146
147impl std::fmt::Debug for super::CreateEntryGroupRequest {
148 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
149 let mut debug_struct = f.debug_struct("CreateEntryGroupRequest");
150 debug_struct.field("parent", &self.parent);
151 debug_struct.field("entry_group_id", &self.entry_group_id);
152 debug_struct.field("entry_group", &self.entry_group);
153 if !self._unknown_fields.is_empty() {
154 debug_struct.field("_unknown_fields", &self._unknown_fields);
155 }
156 debug_struct.finish()
157 }
158}
159
160impl std::fmt::Debug for super::UpdateEntryGroupRequest {
161 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
162 let mut debug_struct = f.debug_struct("UpdateEntryGroupRequest");
163 debug_struct.field("entry_group", &self.entry_group);
164 debug_struct.field("update_mask", &self.update_mask);
165 if !self._unknown_fields.is_empty() {
166 debug_struct.field("_unknown_fields", &self._unknown_fields);
167 }
168 debug_struct.finish()
169 }
170}
171
172impl std::fmt::Debug for super::GetEntryGroupRequest {
173 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
174 let mut debug_struct = f.debug_struct("GetEntryGroupRequest");
175 debug_struct.field("name", &self.name);
176 debug_struct.field("read_mask", &self.read_mask);
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::DeleteEntryGroupRequest {
185 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186 let mut debug_struct = f.debug_struct("DeleteEntryGroupRequest");
187 debug_struct.field("name", &self.name);
188 debug_struct.field("force", &self.force);
189 if !self._unknown_fields.is_empty() {
190 debug_struct.field("_unknown_fields", &self._unknown_fields);
191 }
192 debug_struct.finish()
193 }
194}
195
196impl std::fmt::Debug for super::ListEntryGroupsRequest {
197 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
198 let mut debug_struct = f.debug_struct("ListEntryGroupsRequest");
199 debug_struct.field("parent", &self.parent);
200 debug_struct.field("page_size", &self.page_size);
201 debug_struct.field("page_token", &self.page_token);
202 if !self._unknown_fields.is_empty() {
203 debug_struct.field("_unknown_fields", &self._unknown_fields);
204 }
205 debug_struct.finish()
206 }
207}
208
209impl std::fmt::Debug for super::ListEntryGroupsResponse {
210 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
211 let mut debug_struct = f.debug_struct("ListEntryGroupsResponse");
212 debug_struct.field("entry_groups", &self.entry_groups);
213 debug_struct.field("next_page_token", &self.next_page_token);
214 if !self._unknown_fields.is_empty() {
215 debug_struct.field("_unknown_fields", &self._unknown_fields);
216 }
217 debug_struct.finish()
218 }
219}
220
221impl std::fmt::Debug for super::CreateEntryRequest {
222 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223 let mut debug_struct = f.debug_struct("CreateEntryRequest");
224 debug_struct.field("parent", &self.parent);
225 debug_struct.field("entry_id", &self.entry_id);
226 debug_struct.field("entry", &self.entry);
227 if !self._unknown_fields.is_empty() {
228 debug_struct.field("_unknown_fields", &self._unknown_fields);
229 }
230 debug_struct.finish()
231 }
232}
233
234impl std::fmt::Debug for super::UpdateEntryRequest {
235 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
236 let mut debug_struct = f.debug_struct("UpdateEntryRequest");
237 debug_struct.field("entry", &self.entry);
238 debug_struct.field("update_mask", &self.update_mask);
239 if !self._unknown_fields.is_empty() {
240 debug_struct.field("_unknown_fields", &self._unknown_fields);
241 }
242 debug_struct.finish()
243 }
244}
245
246impl std::fmt::Debug for super::DeleteEntryRequest {
247 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
248 let mut debug_struct = f.debug_struct("DeleteEntryRequest");
249 debug_struct.field("name", &self.name);
250 if !self._unknown_fields.is_empty() {
251 debug_struct.field("_unknown_fields", &self._unknown_fields);
252 }
253 debug_struct.finish()
254 }
255}
256
257impl std::fmt::Debug for super::GetEntryRequest {
258 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
259 let mut debug_struct = f.debug_struct("GetEntryRequest");
260 debug_struct.field("name", &self.name);
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::LookupEntryRequest {
269 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 let mut debug_struct = f.debug_struct("LookupEntryRequest");
271 debug_struct.field("project", &self.project);
272 debug_struct.field("location", &self.location);
273 debug_struct.field("target_name", &self.target_name);
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::Entry {
282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
283 let mut debug_struct = f.debug_struct("Entry");
284 debug_struct.field("name", &self.name);
285 debug_struct.field("linked_resource", &self.linked_resource);
286 debug_struct.field("fully_qualified_name", &self.fully_qualified_name);
287 debug_struct.field("display_name", &self.display_name);
288 debug_struct.field("description", &self.description);
289 debug_struct.field("business_context", &self.business_context);
290 debug_struct.field("schema", &self.schema);
291 debug_struct.field("source_system_timestamps", &self.source_system_timestamps);
292 debug_struct.field("usage_signal", &self.usage_signal);
293 debug_struct.field("labels", &self.labels);
294 debug_struct.field("data_source", &self.data_source);
295 debug_struct.field("personal_details", &self.personal_details);
296 debug_struct.field("entry_type", &self.entry_type);
297 debug_struct.field("system", &self.system);
298 debug_struct.field("system_spec", &self.system_spec);
299 debug_struct.field("type_spec", &self.type_spec);
300 debug_struct.field("spec", &self.spec);
301 if !self._unknown_fields.is_empty() {
302 debug_struct.field("_unknown_fields", &self._unknown_fields);
303 }
304 debug_struct.finish()
305 }
306}
307
308impl std::fmt::Debug for super::DatabaseTableSpec {
309 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
310 let mut debug_struct = f.debug_struct("DatabaseTableSpec");
311 debug_struct.field("r#type", &self.r#type);
312 debug_struct.field("dataplex_table", &self.dataplex_table);
313 debug_struct.field("database_view_spec", &self.database_view_spec);
314 if !self._unknown_fields.is_empty() {
315 debug_struct.field("_unknown_fields", &self._unknown_fields);
316 }
317 debug_struct.finish()
318 }
319}
320
321impl std::fmt::Debug for super::database_table_spec::DatabaseViewSpec {
322 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
323 let mut debug_struct = f.debug_struct("DatabaseViewSpec");
324 debug_struct.field("view_type", &self.view_type);
325 debug_struct.field("source_definition", &self.source_definition);
326 if !self._unknown_fields.is_empty() {
327 debug_struct.field("_unknown_fields", &self._unknown_fields);
328 }
329 debug_struct.finish()
330 }
331}
332
333impl std::fmt::Debug for super::FilesetSpec {
334 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
335 let mut debug_struct = f.debug_struct("FilesetSpec");
336 debug_struct.field("dataplex_fileset", &self.dataplex_fileset);
337 if !self._unknown_fields.is_empty() {
338 debug_struct.field("_unknown_fields", &self._unknown_fields);
339 }
340 debug_struct.finish()
341 }
342}
343
344impl std::fmt::Debug for super::DataSourceConnectionSpec {
345 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
346 let mut debug_struct = f.debug_struct("DataSourceConnectionSpec");
347 debug_struct.field("bigquery_connection_spec", &self.bigquery_connection_spec);
348 if !self._unknown_fields.is_empty() {
349 debug_struct.field("_unknown_fields", &self._unknown_fields);
350 }
351 debug_struct.finish()
352 }
353}
354
355impl std::fmt::Debug for super::RoutineSpec {
356 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357 let mut debug_struct = f.debug_struct("RoutineSpec");
358 debug_struct.field("routine_type", &self.routine_type);
359 debug_struct.field("language", &self.language);
360 debug_struct.field("routine_arguments", &self.routine_arguments);
361 debug_struct.field("return_type", &self.return_type);
362 debug_struct.field("definition_body", &self.definition_body);
363 debug_struct.field("system_spec", &self.system_spec);
364 if !self._unknown_fields.is_empty() {
365 debug_struct.field("_unknown_fields", &self._unknown_fields);
366 }
367 debug_struct.finish()
368 }
369}
370
371impl std::fmt::Debug for super::routine_spec::Argument {
372 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
373 let mut debug_struct = f.debug_struct("Argument");
374 debug_struct.field("name", &self.name);
375 debug_struct.field("mode", &self.mode);
376 debug_struct.field("r#type", &self.r#type);
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::DatasetSpec {
385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 let mut debug_struct = f.debug_struct("DatasetSpec");
387 debug_struct.field("system_spec", &self.system_spec);
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::SqlDatabaseSystemSpec {
396 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
397 let mut debug_struct = f.debug_struct("SqlDatabaseSystemSpec");
398 debug_struct.field("sql_engine", &self.sql_engine);
399 debug_struct.field("database_version", &self.database_version);
400 debug_struct.field("instance_host", &self.instance_host);
401 if !self._unknown_fields.is_empty() {
402 debug_struct.field("_unknown_fields", &self._unknown_fields);
403 }
404 debug_struct.finish()
405 }
406}
407
408impl std::fmt::Debug for super::LookerSystemSpec {
409 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
410 let mut debug_struct = f.debug_struct("LookerSystemSpec");
411 debug_struct.field("parent_instance_id", &self.parent_instance_id);
412 debug_struct.field(
413 "parent_instance_display_name",
414 &self.parent_instance_display_name,
415 );
416 debug_struct.field("parent_model_id", &self.parent_model_id);
417 debug_struct.field("parent_model_display_name", &self.parent_model_display_name);
418 debug_struct.field("parent_view_id", &self.parent_view_id);
419 debug_struct.field("parent_view_display_name", &self.parent_view_display_name);
420 if !self._unknown_fields.is_empty() {
421 debug_struct.field("_unknown_fields", &self._unknown_fields);
422 }
423 debug_struct.finish()
424 }
425}
426
427impl std::fmt::Debug for super::CloudBigtableSystemSpec {
428 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
429 let mut debug_struct = f.debug_struct("CloudBigtableSystemSpec");
430 debug_struct.field("instance_display_name", &self.instance_display_name);
431 if !self._unknown_fields.is_empty() {
432 debug_struct.field("_unknown_fields", &self._unknown_fields);
433 }
434 debug_struct.finish()
435 }
436}
437
438impl std::fmt::Debug for super::CloudBigtableInstanceSpec {
439 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
440 let mut debug_struct = f.debug_struct("CloudBigtableInstanceSpec");
441 debug_struct.field(
442 "cloud_bigtable_cluster_specs",
443 &self.cloud_bigtable_cluster_specs,
444 );
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::cloud_bigtable_instance_spec::CloudBigtableClusterSpec {
453 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
454 let mut debug_struct = f.debug_struct("CloudBigtableClusterSpec");
455 debug_struct.field("display_name", &self.display_name);
456 debug_struct.field("location", &self.location);
457 debug_struct.field("r#type", &self.r#type);
458 debug_struct.field("linked_resource", &self.linked_resource);
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::ServiceSpec {
467 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 let mut debug_struct = f.debug_struct("ServiceSpec");
469 debug_struct.field("system_spec", &self.system_spec);
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::VertexModelSourceInfo {
478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
479 let mut debug_struct = f.debug_struct("VertexModelSourceInfo");
480 debug_struct.field("source_type", &self.source_type);
481 debug_struct.field("copy", &self.copy);
482 if !self._unknown_fields.is_empty() {
483 debug_struct.field("_unknown_fields", &self._unknown_fields);
484 }
485 debug_struct.finish()
486 }
487}
488
489impl std::fmt::Debug for super::VertexModelSpec {
490 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
491 let mut debug_struct = f.debug_struct("VertexModelSpec");
492 debug_struct.field("version_id", &self.version_id);
493 debug_struct.field("version_aliases", &self.version_aliases);
494 debug_struct.field("version_description", &self.version_description);
495 debug_struct.field("vertex_model_source_info", &self.vertex_model_source_info);
496 debug_struct.field("container_image_uri", &self.container_image_uri);
497 if !self._unknown_fields.is_empty() {
498 debug_struct.field("_unknown_fields", &self._unknown_fields);
499 }
500 debug_struct.finish()
501 }
502}
503
504impl std::fmt::Debug for super::VertexDatasetSpec {
505 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
506 let mut debug_struct = f.debug_struct("VertexDatasetSpec");
507 debug_struct.field("data_item_count", &self.data_item_count);
508 debug_struct.field("data_type", &self.data_type);
509 if !self._unknown_fields.is_empty() {
510 debug_struct.field("_unknown_fields", &self._unknown_fields);
511 }
512 debug_struct.finish()
513 }
514}
515
516impl std::fmt::Debug for super::ModelSpec {
517 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
518 let mut debug_struct = f.debug_struct("ModelSpec");
519 debug_struct.field("system_spec", &self.system_spec);
520 if !self._unknown_fields.is_empty() {
521 debug_struct.field("_unknown_fields", &self._unknown_fields);
522 }
523 debug_struct.finish()
524 }
525}
526
527impl std::fmt::Debug for super::FeatureOnlineStoreSpec {
528 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
529 let mut debug_struct = f.debug_struct("FeatureOnlineStoreSpec");
530 debug_struct.field("storage_type", &self.storage_type);
531 if !self._unknown_fields.is_empty() {
532 debug_struct.field("_unknown_fields", &self._unknown_fields);
533 }
534 debug_struct.finish()
535 }
536}
537
538impl std::fmt::Debug for super::BusinessContext {
539 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
540 let mut debug_struct = f.debug_struct("BusinessContext");
541 debug_struct.field("entry_overview", &self.entry_overview);
542 debug_struct.field("contacts", &self.contacts);
543 if !self._unknown_fields.is_empty() {
544 debug_struct.field("_unknown_fields", &self._unknown_fields);
545 }
546 debug_struct.finish()
547 }
548}
549
550impl std::fmt::Debug for super::EntryOverview {
551 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
552 let mut debug_struct = f.debug_struct("EntryOverview");
553 debug_struct.field("overview", &self.overview);
554 if !self._unknown_fields.is_empty() {
555 debug_struct.field("_unknown_fields", &self._unknown_fields);
556 }
557 debug_struct.finish()
558 }
559}
560
561impl std::fmt::Debug for super::Contacts {
562 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
563 let mut debug_struct = f.debug_struct("Contacts");
564 debug_struct.field("people", &self.people);
565 if !self._unknown_fields.is_empty() {
566 debug_struct.field("_unknown_fields", &self._unknown_fields);
567 }
568 debug_struct.finish()
569 }
570}
571
572impl std::fmt::Debug for super::contacts::Person {
573 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
574 let mut debug_struct = f.debug_struct("Person");
575 debug_struct.field("designation", &self.designation);
576 debug_struct.field("email", &self.email);
577 if !self._unknown_fields.is_empty() {
578 debug_struct.field("_unknown_fields", &self._unknown_fields);
579 }
580 debug_struct.finish()
581 }
582}
583
584impl std::fmt::Debug for super::EntryGroup {
585 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
586 let mut debug_struct = f.debug_struct("EntryGroup");
587 debug_struct.field("name", &self.name);
588 debug_struct.field("display_name", &self.display_name);
589 debug_struct.field("description", &self.description);
590 debug_struct.field("data_catalog_timestamps", &self.data_catalog_timestamps);
591 debug_struct.field("transferred_to_dataplex", &self.transferred_to_dataplex);
592 if !self._unknown_fields.is_empty() {
593 debug_struct.field("_unknown_fields", &self._unknown_fields);
594 }
595 debug_struct.finish()
596 }
597}
598
599impl std::fmt::Debug for super::CreateTagTemplateRequest {
600 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
601 let mut debug_struct = f.debug_struct("CreateTagTemplateRequest");
602 debug_struct.field("parent", &self.parent);
603 debug_struct.field("tag_template_id", &self.tag_template_id);
604 debug_struct.field("tag_template", &self.tag_template);
605 if !self._unknown_fields.is_empty() {
606 debug_struct.field("_unknown_fields", &self._unknown_fields);
607 }
608 debug_struct.finish()
609 }
610}
611
612impl std::fmt::Debug for super::GetTagTemplateRequest {
613 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
614 let mut debug_struct = f.debug_struct("GetTagTemplateRequest");
615 debug_struct.field("name", &self.name);
616 if !self._unknown_fields.is_empty() {
617 debug_struct.field("_unknown_fields", &self._unknown_fields);
618 }
619 debug_struct.finish()
620 }
621}
622
623impl std::fmt::Debug for super::UpdateTagTemplateRequest {
624 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
625 let mut debug_struct = f.debug_struct("UpdateTagTemplateRequest");
626 debug_struct.field("tag_template", &self.tag_template);
627 debug_struct.field("update_mask", &self.update_mask);
628 if !self._unknown_fields.is_empty() {
629 debug_struct.field("_unknown_fields", &self._unknown_fields);
630 }
631 debug_struct.finish()
632 }
633}
634
635impl std::fmt::Debug for super::DeleteTagTemplateRequest {
636 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
637 let mut debug_struct = f.debug_struct("DeleteTagTemplateRequest");
638 debug_struct.field("name", &self.name);
639 debug_struct.field("force", &self.force);
640 if !self._unknown_fields.is_empty() {
641 debug_struct.field("_unknown_fields", &self._unknown_fields);
642 }
643 debug_struct.finish()
644 }
645}
646
647impl std::fmt::Debug for super::CreateTagRequest {
648 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
649 let mut debug_struct = f.debug_struct("CreateTagRequest");
650 debug_struct.field("parent", &self.parent);
651 debug_struct.field("tag", &self.tag);
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 for super::UpdateTagRequest {
660 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
661 let mut debug_struct = f.debug_struct("UpdateTagRequest");
662 debug_struct.field("tag", &self.tag);
663 debug_struct.field("update_mask", &self.update_mask);
664 if !self._unknown_fields.is_empty() {
665 debug_struct.field("_unknown_fields", &self._unknown_fields);
666 }
667 debug_struct.finish()
668 }
669}
670
671impl std::fmt::Debug for super::DeleteTagRequest {
672 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
673 let mut debug_struct = f.debug_struct("DeleteTagRequest");
674 debug_struct.field("name", &self.name);
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::CreateTagTemplateFieldRequest {
683 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
684 let mut debug_struct = f.debug_struct("CreateTagTemplateFieldRequest");
685 debug_struct.field("parent", &self.parent);
686 debug_struct.field("tag_template_field_id", &self.tag_template_field_id);
687 debug_struct.field("tag_template_field", &self.tag_template_field);
688 if !self._unknown_fields.is_empty() {
689 debug_struct.field("_unknown_fields", &self._unknown_fields);
690 }
691 debug_struct.finish()
692 }
693}
694
695impl std::fmt::Debug for super::UpdateTagTemplateFieldRequest {
696 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
697 let mut debug_struct = f.debug_struct("UpdateTagTemplateFieldRequest");
698 debug_struct.field("name", &self.name);
699 debug_struct.field("tag_template_field", &self.tag_template_field);
700 debug_struct.field("update_mask", &self.update_mask);
701 if !self._unknown_fields.is_empty() {
702 debug_struct.field("_unknown_fields", &self._unknown_fields);
703 }
704 debug_struct.finish()
705 }
706}
707
708impl std::fmt::Debug for super::RenameTagTemplateFieldRequest {
709 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
710 let mut debug_struct = f.debug_struct("RenameTagTemplateFieldRequest");
711 debug_struct.field("name", &self.name);
712 debug_struct.field("new_tag_template_field_id", &self.new_tag_template_field_id);
713 if !self._unknown_fields.is_empty() {
714 debug_struct.field("_unknown_fields", &self._unknown_fields);
715 }
716 debug_struct.finish()
717 }
718}
719
720impl std::fmt::Debug for super::RenameTagTemplateFieldEnumValueRequest {
721 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
722 let mut debug_struct = f.debug_struct("RenameTagTemplateFieldEnumValueRequest");
723 debug_struct.field("name", &self.name);
724 debug_struct.field(
725 "new_enum_value_display_name",
726 &self.new_enum_value_display_name,
727 );
728 if !self._unknown_fields.is_empty() {
729 debug_struct.field("_unknown_fields", &self._unknown_fields);
730 }
731 debug_struct.finish()
732 }
733}
734
735impl std::fmt::Debug for super::DeleteTagTemplateFieldRequest {
736 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
737 let mut debug_struct = f.debug_struct("DeleteTagTemplateFieldRequest");
738 debug_struct.field("name", &self.name);
739 debug_struct.field("force", &self.force);
740 if !self._unknown_fields.is_empty() {
741 debug_struct.field("_unknown_fields", &self._unknown_fields);
742 }
743 debug_struct.finish()
744 }
745}
746
747impl std::fmt::Debug for super::ListTagsRequest {
748 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
749 let mut debug_struct = f.debug_struct("ListTagsRequest");
750 debug_struct.field("parent", &self.parent);
751 debug_struct.field("page_size", &self.page_size);
752 debug_struct.field("page_token", &self.page_token);
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::ListTagsResponse {
761 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
762 let mut debug_struct = f.debug_struct("ListTagsResponse");
763 debug_struct.field("tags", &self.tags);
764 debug_struct.field("next_page_token", &self.next_page_token);
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::ReconcileTagsRequest {
773 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774 let mut debug_struct = f.debug_struct("ReconcileTagsRequest");
775 debug_struct.field("parent", &self.parent);
776 debug_struct.field("tag_template", &self.tag_template);
777 debug_struct.field("force_delete_missing", &self.force_delete_missing);
778 debug_struct.field("tags", &self.tags);
779 if !self._unknown_fields.is_empty() {
780 debug_struct.field("_unknown_fields", &self._unknown_fields);
781 }
782 debug_struct.finish()
783 }
784}
785
786impl std::fmt::Debug for super::ReconcileTagsResponse {
787 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
788 let mut debug_struct = f.debug_struct("ReconcileTagsResponse");
789 debug_struct.field("created_tags_count", &self.created_tags_count);
790 debug_struct.field("updated_tags_count", &self.updated_tags_count);
791 debug_struct.field("deleted_tags_count", &self.deleted_tags_count);
792 if !self._unknown_fields.is_empty() {
793 debug_struct.field("_unknown_fields", &self._unknown_fields);
794 }
795 debug_struct.finish()
796 }
797}
798
799impl std::fmt::Debug for super::ReconcileTagsMetadata {
800 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
801 let mut debug_struct = f.debug_struct("ReconcileTagsMetadata");
802 debug_struct.field("state", &self.state);
803 debug_struct.field("errors", &self.errors);
804 if !self._unknown_fields.is_empty() {
805 debug_struct.field("_unknown_fields", &self._unknown_fields);
806 }
807 debug_struct.finish()
808 }
809}
810
811impl std::fmt::Debug for super::ListEntriesRequest {
812 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
813 let mut debug_struct = f.debug_struct("ListEntriesRequest");
814 debug_struct.field("parent", &self.parent);
815 debug_struct.field("page_size", &self.page_size);
816 debug_struct.field("page_token", &self.page_token);
817 debug_struct.field("read_mask", &self.read_mask);
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::ListEntriesResponse {
826 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
827 let mut debug_struct = f.debug_struct("ListEntriesResponse");
828 debug_struct.field("entries", &self.entries);
829 debug_struct.field("next_page_token", &self.next_page_token);
830 if !self._unknown_fields.is_empty() {
831 debug_struct.field("_unknown_fields", &self._unknown_fields);
832 }
833 debug_struct.finish()
834 }
835}
836
837impl std::fmt::Debug for super::StarEntryRequest {
838 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
839 let mut debug_struct = f.debug_struct("StarEntryRequest");
840 debug_struct.field("name", &self.name);
841 if !self._unknown_fields.is_empty() {
842 debug_struct.field("_unknown_fields", &self._unknown_fields);
843 }
844 debug_struct.finish()
845 }
846}
847
848impl std::fmt::Debug for super::StarEntryResponse {
849 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
850 let mut debug_struct = f.debug_struct("StarEntryResponse");
851 if !self._unknown_fields.is_empty() {
852 debug_struct.field("_unknown_fields", &self._unknown_fields);
853 }
854 debug_struct.finish()
855 }
856}
857
858impl std::fmt::Debug for super::UnstarEntryRequest {
859 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
860 let mut debug_struct = f.debug_struct("UnstarEntryRequest");
861 debug_struct.field("name", &self.name);
862 if !self._unknown_fields.is_empty() {
863 debug_struct.field("_unknown_fields", &self._unknown_fields);
864 }
865 debug_struct.finish()
866 }
867}
868
869impl std::fmt::Debug for super::UnstarEntryResponse {
870 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
871 let mut debug_struct = f.debug_struct("UnstarEntryResponse");
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::ImportEntriesRequest {
880 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
881 let mut debug_struct = f.debug_struct("ImportEntriesRequest");
882 debug_struct.field("parent", &self.parent);
883 debug_struct.field("job_id", &self.job_id);
884 debug_struct.field("source", &self.source);
885 if !self._unknown_fields.is_empty() {
886 debug_struct.field("_unknown_fields", &self._unknown_fields);
887 }
888 debug_struct.finish()
889 }
890}
891
892impl std::fmt::Debug for super::ImportEntriesResponse {
893 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
894 let mut debug_struct = f.debug_struct("ImportEntriesResponse");
895 debug_struct.field("upserted_entries_count", &self.upserted_entries_count);
896 debug_struct.field("deleted_entries_count", &self.deleted_entries_count);
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::ImportEntriesMetadata {
905 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
906 let mut debug_struct = f.debug_struct("ImportEntriesMetadata");
907 debug_struct.field("state", &self.state);
908 debug_struct.field("errors", &self.errors);
909 if !self._unknown_fields.is_empty() {
910 debug_struct.field("_unknown_fields", &self._unknown_fields);
911 }
912 debug_struct.finish()
913 }
914}
915
916impl std::fmt::Debug for super::ModifyEntryOverviewRequest {
917 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918 let mut debug_struct = f.debug_struct("ModifyEntryOverviewRequest");
919 debug_struct.field("name", &self.name);
920 debug_struct.field("entry_overview", &self.entry_overview);
921 if !self._unknown_fields.is_empty() {
922 debug_struct.field("_unknown_fields", &self._unknown_fields);
923 }
924 debug_struct.finish()
925 }
926}
927
928impl std::fmt::Debug for super::ModifyEntryContactsRequest {
929 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
930 let mut debug_struct = f.debug_struct("ModifyEntryContactsRequest");
931 debug_struct.field("name", &self.name);
932 debug_struct.field("contacts", &self.contacts);
933 if !self._unknown_fields.is_empty() {
934 debug_struct.field("_unknown_fields", &self._unknown_fields);
935 }
936 debug_struct.finish()
937 }
938}
939
940impl std::fmt::Debug for super::SetConfigRequest {
941 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
942 let mut debug_struct = f.debug_struct("SetConfigRequest");
943 debug_struct.field("name", &self.name);
944 debug_struct.field("configuration", &self.configuration);
945 if !self._unknown_fields.is_empty() {
946 debug_struct.field("_unknown_fields", &self._unknown_fields);
947 }
948 debug_struct.finish()
949 }
950}
951
952impl std::fmt::Debug for super::RetrieveConfigRequest {
953 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954 let mut debug_struct = f.debug_struct("RetrieveConfigRequest");
955 debug_struct.field("name", &self.name);
956 if !self._unknown_fields.is_empty() {
957 debug_struct.field("_unknown_fields", &self._unknown_fields);
958 }
959 debug_struct.finish()
960 }
961}
962
963impl std::fmt::Debug for super::RetrieveEffectiveConfigRequest {
964 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
965 let mut debug_struct = f.debug_struct("RetrieveEffectiveConfigRequest");
966 debug_struct.field("name", &self.name);
967 if !self._unknown_fields.is_empty() {
968 debug_struct.field("_unknown_fields", &self._unknown_fields);
969 }
970 debug_struct.finish()
971 }
972}
973
974impl std::fmt::Debug for super::OrganizationConfig {
975 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
976 let mut debug_struct = f.debug_struct("OrganizationConfig");
977 debug_struct.field("config", &self.config);
978 if !self._unknown_fields.is_empty() {
979 debug_struct.field("_unknown_fields", &self._unknown_fields);
980 }
981 debug_struct.finish()
982 }
983}
984
985impl std::fmt::Debug for super::MigrationConfig {
986 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
987 let mut debug_struct = f.debug_struct("MigrationConfig");
988 debug_struct.field("tag_template_migration", &self.tag_template_migration);
989 debug_struct.field("catalog_ui_experience", &self.catalog_ui_experience);
990 debug_struct.field(
991 "template_migration_enabled_time",
992 &self.template_migration_enabled_time,
993 );
994 if !self._unknown_fields.is_empty() {
995 debug_struct.field("_unknown_fields", &self._unknown_fields);
996 }
997 debug_struct.finish()
998 }
999}
1000
1001impl std::fmt::Debug for super::DataplexSpec {
1002 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1003 let mut debug_struct = f.debug_struct("DataplexSpec");
1004 debug_struct.field("asset", &self.asset);
1005 debug_struct.field("data_format", &self.data_format);
1006 debug_struct.field("compression_format", &self.compression_format);
1007 debug_struct.field("project_id", &self.project_id);
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::DataplexFilesetSpec {
1016 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1017 let mut debug_struct = f.debug_struct("DataplexFilesetSpec");
1018 debug_struct.field("dataplex_spec", &self.dataplex_spec);
1019 if !self._unknown_fields.is_empty() {
1020 debug_struct.field("_unknown_fields", &self._unknown_fields);
1021 }
1022 debug_struct.finish()
1023 }
1024}
1025
1026impl std::fmt::Debug for super::DataplexTableSpec {
1027 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1028 let mut debug_struct = f.debug_struct("DataplexTableSpec");
1029 debug_struct.field("external_tables", &self.external_tables);
1030 debug_struct.field("dataplex_spec", &self.dataplex_spec);
1031 debug_struct.field("user_managed", &self.user_managed);
1032 if !self._unknown_fields.is_empty() {
1033 debug_struct.field("_unknown_fields", &self._unknown_fields);
1034 }
1035 debug_struct.finish()
1036 }
1037}
1038
1039impl std::fmt::Debug for super::DataplexExternalTable {
1040 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1041 let mut debug_struct = f.debug_struct("DataplexExternalTable");
1042 debug_struct.field("system", &self.system);
1043 debug_struct.field("fully_qualified_name", &self.fully_qualified_name);
1044 debug_struct.field("google_cloud_resource", &self.google_cloud_resource);
1045 debug_struct.field("data_catalog_entry", &self.data_catalog_entry);
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::TaggedEntry {
1054 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1055 let mut debug_struct = f.debug_struct("TaggedEntry");
1056 debug_struct.field("present_tags", &self.present_tags);
1057 debug_struct.field("absent_tags", &self.absent_tags);
1058 debug_struct.field("entry", &self.entry);
1059 if !self._unknown_fields.is_empty() {
1060 debug_struct.field("_unknown_fields", &self._unknown_fields);
1061 }
1062 debug_struct.finish()
1063 }
1064}
1065
1066impl std::fmt::Debug for super::DumpItem {
1067 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1068 let mut debug_struct = f.debug_struct("DumpItem");
1069 debug_struct.field("item", &self.item);
1070 if !self._unknown_fields.is_empty() {
1071 debug_struct.field("_unknown_fields", &self._unknown_fields);
1072 }
1073 debug_struct.finish()
1074 }
1075}
1076
1077impl std::fmt::Debug for super::GcsFilesetSpec {
1078 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1079 let mut debug_struct = f.debug_struct("GcsFilesetSpec");
1080 debug_struct.field("file_patterns", &self.file_patterns);
1081 debug_struct.field("sample_gcs_file_specs", &self.sample_gcs_file_specs);
1082 if !self._unknown_fields.is_empty() {
1083 debug_struct.field("_unknown_fields", &self._unknown_fields);
1084 }
1085 debug_struct.finish()
1086 }
1087}
1088
1089impl std::fmt::Debug for super::GcsFileSpec {
1090 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1091 let mut debug_struct = f.debug_struct("GcsFileSpec");
1092 debug_struct.field("file_path", &self.file_path);
1093 debug_struct.field("gcs_timestamps", &self.gcs_timestamps);
1094 debug_struct.field("size_bytes", &self.size_bytes);
1095 if !self._unknown_fields.is_empty() {
1096 debug_struct.field("_unknown_fields", &self._unknown_fields);
1097 }
1098 debug_struct.finish()
1099 }
1100}
1101
1102impl std::fmt::Debug for super::PhysicalSchema {
1103 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1104 let mut debug_struct = f.debug_struct("PhysicalSchema");
1105 debug_struct.field("schema", &self.schema);
1106 if !self._unknown_fields.is_empty() {
1107 debug_struct.field("_unknown_fields", &self._unknown_fields);
1108 }
1109 debug_struct.finish()
1110 }
1111}
1112
1113impl std::fmt::Debug for super::physical_schema::AvroSchema {
1114 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1115 let mut debug_struct = f.debug_struct("AvroSchema");
1116 debug_struct.field("text", &self.text);
1117 if !self._unknown_fields.is_empty() {
1118 debug_struct.field("_unknown_fields", &self._unknown_fields);
1119 }
1120 debug_struct.finish()
1121 }
1122}
1123
1124impl std::fmt::Debug for super::physical_schema::ThriftSchema {
1125 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1126 let mut debug_struct = f.debug_struct("ThriftSchema");
1127 debug_struct.field("text", &self.text);
1128 if !self._unknown_fields.is_empty() {
1129 debug_struct.field("_unknown_fields", &self._unknown_fields);
1130 }
1131 debug_struct.finish()
1132 }
1133}
1134
1135impl std::fmt::Debug for super::physical_schema::ProtobufSchema {
1136 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1137 let mut debug_struct = f.debug_struct("ProtobufSchema");
1138 debug_struct.field("text", &self.text);
1139 if !self._unknown_fields.is_empty() {
1140 debug_struct.field("_unknown_fields", &self._unknown_fields);
1141 }
1142 debug_struct.finish()
1143 }
1144}
1145
1146impl std::fmt::Debug for super::physical_schema::ParquetSchema {
1147 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1148 let mut debug_struct = f.debug_struct("ParquetSchema");
1149 if !self._unknown_fields.is_empty() {
1150 debug_struct.field("_unknown_fields", &self._unknown_fields);
1151 }
1152 debug_struct.finish()
1153 }
1154}
1155
1156impl std::fmt::Debug for super::physical_schema::OrcSchema {
1157 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1158 let mut debug_struct = f.debug_struct("OrcSchema");
1159 if !self._unknown_fields.is_empty() {
1160 debug_struct.field("_unknown_fields", &self._unknown_fields);
1161 }
1162 debug_struct.finish()
1163 }
1164}
1165
1166impl std::fmt::Debug for super::physical_schema::CsvSchema {
1167 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1168 let mut debug_struct = f.debug_struct("CsvSchema");
1169 if !self._unknown_fields.is_empty() {
1170 debug_struct.field("_unknown_fields", &self._unknown_fields);
1171 }
1172 debug_struct.finish()
1173 }
1174}
1175
1176impl std::fmt::Debug for super::Taxonomy {
1177 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1178 let mut debug_struct = f.debug_struct("Taxonomy");
1179 debug_struct.field("name", &self.name);
1180 debug_struct.field("display_name", &self.display_name);
1181 debug_struct.field("description", &self.description);
1182 debug_struct.field("policy_tag_count", &self.policy_tag_count);
1183 debug_struct.field("taxonomy_timestamps", &self.taxonomy_timestamps);
1184 debug_struct.field("activated_policy_types", &self.activated_policy_types);
1185 debug_struct.field("service", &self.service);
1186 if !self._unknown_fields.is_empty() {
1187 debug_struct.field("_unknown_fields", &self._unknown_fields);
1188 }
1189 debug_struct.finish()
1190 }
1191}
1192
1193impl std::fmt::Debug for super::taxonomy::Service {
1194 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1195 let mut debug_struct = f.debug_struct("Service");
1196 debug_struct.field("name", &self.name);
1197 debug_struct.field("identity", &self.identity);
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::PolicyTag {
1206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1207 let mut debug_struct = f.debug_struct("PolicyTag");
1208 debug_struct.field("name", &self.name);
1209 debug_struct.field("display_name", &self.display_name);
1210 debug_struct.field("description", &self.description);
1211 debug_struct.field("parent_policy_tag", &self.parent_policy_tag);
1212 debug_struct.field("child_policy_tags", &self.child_policy_tags);
1213 if !self._unknown_fields.is_empty() {
1214 debug_struct.field("_unknown_fields", &self._unknown_fields);
1215 }
1216 debug_struct.finish()
1217 }
1218}
1219
1220impl std::fmt::Debug for super::CreateTaxonomyRequest {
1221 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1222 let mut debug_struct = f.debug_struct("CreateTaxonomyRequest");
1223 debug_struct.field("parent", &self.parent);
1224 debug_struct.field("taxonomy", &self.taxonomy);
1225 if !self._unknown_fields.is_empty() {
1226 debug_struct.field("_unknown_fields", &self._unknown_fields);
1227 }
1228 debug_struct.finish()
1229 }
1230}
1231
1232impl std::fmt::Debug for super::DeleteTaxonomyRequest {
1233 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1234 let mut debug_struct = f.debug_struct("DeleteTaxonomyRequest");
1235 debug_struct.field("name", &self.name);
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::UpdateTaxonomyRequest {
1244 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1245 let mut debug_struct = f.debug_struct("UpdateTaxonomyRequest");
1246 debug_struct.field("taxonomy", &self.taxonomy);
1247 debug_struct.field("update_mask", &self.update_mask);
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::ListTaxonomiesRequest {
1256 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1257 let mut debug_struct = f.debug_struct("ListTaxonomiesRequest");
1258 debug_struct.field("parent", &self.parent);
1259 debug_struct.field("page_size", &self.page_size);
1260 debug_struct.field("page_token", &self.page_token);
1261 debug_struct.field("filter", &self.filter);
1262 if !self._unknown_fields.is_empty() {
1263 debug_struct.field("_unknown_fields", &self._unknown_fields);
1264 }
1265 debug_struct.finish()
1266 }
1267}
1268
1269impl std::fmt::Debug for super::ListTaxonomiesResponse {
1270 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1271 let mut debug_struct = f.debug_struct("ListTaxonomiesResponse");
1272 debug_struct.field("taxonomies", &self.taxonomies);
1273 debug_struct.field("next_page_token", &self.next_page_token);
1274 if !self._unknown_fields.is_empty() {
1275 debug_struct.field("_unknown_fields", &self._unknown_fields);
1276 }
1277 debug_struct.finish()
1278 }
1279}
1280
1281impl std::fmt::Debug for super::GetTaxonomyRequest {
1282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1283 let mut debug_struct = f.debug_struct("GetTaxonomyRequest");
1284 debug_struct.field("name", &self.name);
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::CreatePolicyTagRequest {
1293 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1294 let mut debug_struct = f.debug_struct("CreatePolicyTagRequest");
1295 debug_struct.field("parent", &self.parent);
1296 debug_struct.field("policy_tag", &self.policy_tag);
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::DeletePolicyTagRequest {
1305 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1306 let mut debug_struct = f.debug_struct("DeletePolicyTagRequest");
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::UpdatePolicyTagRequest {
1316 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1317 let mut debug_struct = f.debug_struct("UpdatePolicyTagRequest");
1318 debug_struct.field("policy_tag", &self.policy_tag);
1319 debug_struct.field("update_mask", &self.update_mask);
1320 if !self._unknown_fields.is_empty() {
1321 debug_struct.field("_unknown_fields", &self._unknown_fields);
1322 }
1323 debug_struct.finish()
1324 }
1325}
1326
1327impl std::fmt::Debug for super::ListPolicyTagsRequest {
1328 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1329 let mut debug_struct = f.debug_struct("ListPolicyTagsRequest");
1330 debug_struct.field("parent", &self.parent);
1331 debug_struct.field("page_size", &self.page_size);
1332 debug_struct.field("page_token", &self.page_token);
1333 if !self._unknown_fields.is_empty() {
1334 debug_struct.field("_unknown_fields", &self._unknown_fields);
1335 }
1336 debug_struct.finish()
1337 }
1338}
1339
1340impl std::fmt::Debug for super::ListPolicyTagsResponse {
1341 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1342 let mut debug_struct = f.debug_struct("ListPolicyTagsResponse");
1343 debug_struct.field("policy_tags", &self.policy_tags);
1344 debug_struct.field("next_page_token", &self.next_page_token);
1345 if !self._unknown_fields.is_empty() {
1346 debug_struct.field("_unknown_fields", &self._unknown_fields);
1347 }
1348 debug_struct.finish()
1349 }
1350}
1351
1352impl std::fmt::Debug for super::GetPolicyTagRequest {
1353 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1354 let mut debug_struct = f.debug_struct("GetPolicyTagRequest");
1355 debug_struct.field("name", &self.name);
1356 if !self._unknown_fields.is_empty() {
1357 debug_struct.field("_unknown_fields", &self._unknown_fields);
1358 }
1359 debug_struct.finish()
1360 }
1361}
1362
1363impl std::fmt::Debug for super::SerializedTaxonomy {
1364 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1365 let mut debug_struct = f.debug_struct("SerializedTaxonomy");
1366 debug_struct.field("display_name", &self.display_name);
1367 debug_struct.field("description", &self.description);
1368 debug_struct.field("policy_tags", &self.policy_tags);
1369 debug_struct.field("activated_policy_types", &self.activated_policy_types);
1370 if !self._unknown_fields.is_empty() {
1371 debug_struct.field("_unknown_fields", &self._unknown_fields);
1372 }
1373 debug_struct.finish()
1374 }
1375}
1376
1377impl std::fmt::Debug for super::SerializedPolicyTag {
1378 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1379 let mut debug_struct = f.debug_struct("SerializedPolicyTag");
1380 debug_struct.field("policy_tag", &self.policy_tag);
1381 debug_struct.field("display_name", &self.display_name);
1382 debug_struct.field("description", &self.description);
1383 debug_struct.field("child_policy_tags", &self.child_policy_tags);
1384 if !self._unknown_fields.is_empty() {
1385 debug_struct.field("_unknown_fields", &self._unknown_fields);
1386 }
1387 debug_struct.finish()
1388 }
1389}
1390
1391impl std::fmt::Debug for super::ReplaceTaxonomyRequest {
1392 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1393 let mut debug_struct = f.debug_struct("ReplaceTaxonomyRequest");
1394 debug_struct.field("name", &self.name);
1395 debug_struct.field("serialized_taxonomy", &self.serialized_taxonomy);
1396 if !self._unknown_fields.is_empty() {
1397 debug_struct.field("_unknown_fields", &self._unknown_fields);
1398 }
1399 debug_struct.finish()
1400 }
1401}
1402
1403impl std::fmt::Debug for super::ImportTaxonomiesRequest {
1404 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1405 let mut debug_struct = f.debug_struct("ImportTaxonomiesRequest");
1406 debug_struct.field("parent", &self.parent);
1407 debug_struct.field("source", &self.source);
1408 if !self._unknown_fields.is_empty() {
1409 debug_struct.field("_unknown_fields", &self._unknown_fields);
1410 }
1411 debug_struct.finish()
1412 }
1413}
1414
1415impl std::fmt::Debug for super::InlineSource {
1416 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1417 let mut debug_struct = f.debug_struct("InlineSource");
1418 debug_struct.field("taxonomies", &self.taxonomies);
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::CrossRegionalSource {
1427 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1428 let mut debug_struct = f.debug_struct("CrossRegionalSource");
1429 debug_struct.field("taxonomy", &self.taxonomy);
1430 if !self._unknown_fields.is_empty() {
1431 debug_struct.field("_unknown_fields", &self._unknown_fields);
1432 }
1433 debug_struct.finish()
1434 }
1435}
1436
1437impl std::fmt::Debug for super::ImportTaxonomiesResponse {
1438 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1439 let mut debug_struct = f.debug_struct("ImportTaxonomiesResponse");
1440 debug_struct.field("taxonomies", &self.taxonomies);
1441 if !self._unknown_fields.is_empty() {
1442 debug_struct.field("_unknown_fields", &self._unknown_fields);
1443 }
1444 debug_struct.finish()
1445 }
1446}
1447
1448impl std::fmt::Debug for super::ExportTaxonomiesRequest {
1449 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1450 let mut debug_struct = f.debug_struct("ExportTaxonomiesRequest");
1451 debug_struct.field("parent", &self.parent);
1452 debug_struct.field("taxonomies", &self.taxonomies);
1453 debug_struct.field("destination", &self.destination);
1454 if !self._unknown_fields.is_empty() {
1455 debug_struct.field("_unknown_fields", &self._unknown_fields);
1456 }
1457 debug_struct.finish()
1458 }
1459}
1460
1461impl std::fmt::Debug for super::ExportTaxonomiesResponse {
1462 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1463 let mut debug_struct = f.debug_struct("ExportTaxonomiesResponse");
1464 debug_struct.field("taxonomies", &self.taxonomies);
1465 if !self._unknown_fields.is_empty() {
1466 debug_struct.field("_unknown_fields", &self._unknown_fields);
1467 }
1468 debug_struct.finish()
1469 }
1470}
1471
1472impl std::fmt::Debug for super::Schema {
1473 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1474 let mut debug_struct = f.debug_struct("Schema");
1475 debug_struct.field("columns", &self.columns);
1476 if !self._unknown_fields.is_empty() {
1477 debug_struct.field("_unknown_fields", &self._unknown_fields);
1478 }
1479 debug_struct.finish()
1480 }
1481}
1482
1483impl std::fmt::Debug for super::ColumnSchema {
1484 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1485 let mut debug_struct = f.debug_struct("ColumnSchema");
1486 debug_struct.field("column", &self.column);
1487 debug_struct.field("r#type", &self.r#type);
1488 debug_struct.field("description", &self.description);
1489 debug_struct.field("mode", &self.mode);
1490 debug_struct.field("default_value", &self.default_value);
1491 debug_struct.field("ordinal_position", &self.ordinal_position);
1492 debug_struct.field("highest_indexing_type", &self.highest_indexing_type);
1493 debug_struct.field("subcolumns", &self.subcolumns);
1494 debug_struct.field("range_element_type", &self.range_element_type);
1495 debug_struct.field("gc_rule", &self.gc_rule);
1496 debug_struct.field("system_spec", &self.system_spec);
1497 if !self._unknown_fields.is_empty() {
1498 debug_struct.field("_unknown_fields", &self._unknown_fields);
1499 }
1500 debug_struct.finish()
1501 }
1502}
1503
1504impl std::fmt::Debug for super::column_schema::LookerColumnSpec {
1505 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1506 let mut debug_struct = f.debug_struct("LookerColumnSpec");
1507 debug_struct.field("r#type", &self.r#type);
1508 if !self._unknown_fields.is_empty() {
1509 debug_struct.field("_unknown_fields", &self._unknown_fields);
1510 }
1511 debug_struct.finish()
1512 }
1513}
1514
1515impl std::fmt::Debug for super::column_schema::FieldElementType {
1516 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1517 let mut debug_struct = f.debug_struct("FieldElementType");
1518 debug_struct.field("r#type", &self.r#type);
1519 if !self._unknown_fields.is_empty() {
1520 debug_struct.field("_unknown_fields", &self._unknown_fields);
1521 }
1522 debug_struct.finish()
1523 }
1524}
1525
1526impl std::fmt::Debug for super::SearchCatalogResult {
1527 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1528 let mut debug_struct = f.debug_struct("SearchCatalogResult");
1529 debug_struct.field("search_result_type", &self.search_result_type);
1530 debug_struct.field("search_result_subtype", &self.search_result_subtype);
1531 debug_struct.field("relative_resource_name", &self.relative_resource_name);
1532 debug_struct.field("linked_resource", &self.linked_resource);
1533 debug_struct.field("modify_time", &self.modify_time);
1534 debug_struct.field("fully_qualified_name", &self.fully_qualified_name);
1535 debug_struct.field("display_name", &self.display_name);
1536 debug_struct.field("description", &self.description);
1537 debug_struct.field("system", &self.system);
1538 if !self._unknown_fields.is_empty() {
1539 debug_struct.field("_unknown_fields", &self._unknown_fields);
1540 }
1541 debug_struct.finish()
1542 }
1543}
1544
1545impl std::fmt::Debug for super::BigQueryTableSpec {
1546 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1547 let mut debug_struct = f.debug_struct("BigQueryTableSpec");
1548 debug_struct.field("table_source_type", &self.table_source_type);
1549 debug_struct.field("type_spec", &self.type_spec);
1550 if !self._unknown_fields.is_empty() {
1551 debug_struct.field("_unknown_fields", &self._unknown_fields);
1552 }
1553 debug_struct.finish()
1554 }
1555}
1556
1557impl std::fmt::Debug for super::ViewSpec {
1558 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1559 let mut debug_struct = f.debug_struct("ViewSpec");
1560 debug_struct.field("view_query", &self.view_query);
1561 if !self._unknown_fields.is_empty() {
1562 debug_struct.field("_unknown_fields", &self._unknown_fields);
1563 }
1564 debug_struct.finish()
1565 }
1566}
1567
1568impl std::fmt::Debug for super::TableSpec {
1569 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1570 let mut debug_struct = f.debug_struct("TableSpec");
1571 debug_struct.field("grouped_entry", &self.grouped_entry);
1572 if !self._unknown_fields.is_empty() {
1573 debug_struct.field("_unknown_fields", &self._unknown_fields);
1574 }
1575 debug_struct.finish()
1576 }
1577}
1578
1579impl std::fmt::Debug for super::BigQueryDateShardedSpec {
1580 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1581 let mut debug_struct = f.debug_struct("BigQueryDateShardedSpec");
1582 debug_struct.field("dataset", &self.dataset);
1583 debug_struct.field("table_prefix", &self.table_prefix);
1584 debug_struct.field("shard_count", &self.shard_count);
1585 debug_struct.field("latest_shard_resource", &self.latest_shard_resource);
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::Tag {
1594 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1595 let mut debug_struct = f.debug_struct("Tag");
1596 debug_struct.field("name", &self.name);
1597 debug_struct.field("template", &self.template);
1598 debug_struct.field("template_display_name", &self.template_display_name);
1599 debug_struct.field("fields", &self.fields);
1600 debug_struct.field("dataplex_transfer_status", &self.dataplex_transfer_status);
1601 debug_struct.field("scope", &self.scope);
1602 if !self._unknown_fields.is_empty() {
1603 debug_struct.field("_unknown_fields", &self._unknown_fields);
1604 }
1605 debug_struct.finish()
1606 }
1607}
1608
1609impl std::fmt::Debug for super::TagField {
1610 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1611 let mut debug_struct = f.debug_struct("TagField");
1612 debug_struct.field("display_name", &self.display_name);
1613 debug_struct.field("order", &self.order);
1614 debug_struct.field("kind", &self.kind);
1615 if !self._unknown_fields.is_empty() {
1616 debug_struct.field("_unknown_fields", &self._unknown_fields);
1617 }
1618 debug_struct.finish()
1619 }
1620}
1621
1622impl std::fmt::Debug for super::tag_field::EnumValue {
1623 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1624 let mut debug_struct = f.debug_struct("EnumValue");
1625 debug_struct.field("display_name", &self.display_name);
1626 if !self._unknown_fields.is_empty() {
1627 debug_struct.field("_unknown_fields", &self._unknown_fields);
1628 }
1629 debug_struct.finish()
1630 }
1631}
1632
1633impl std::fmt::Debug for super::TagTemplate {
1634 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1635 let mut debug_struct = f.debug_struct("TagTemplate");
1636 debug_struct.field("name", &self.name);
1637 debug_struct.field("display_name", &self.display_name);
1638 debug_struct.field("is_publicly_readable", &self.is_publicly_readable);
1639 debug_struct.field("fields", &self.fields);
1640 debug_struct.field("dataplex_transfer_status", &self.dataplex_transfer_status);
1641 if !self._unknown_fields.is_empty() {
1642 debug_struct.field("_unknown_fields", &self._unknown_fields);
1643 }
1644 debug_struct.finish()
1645 }
1646}
1647
1648impl std::fmt::Debug for super::TagTemplateField {
1649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1650 let mut debug_struct = f.debug_struct("TagTemplateField");
1651 debug_struct.field("name", &self.name);
1652 debug_struct.field("display_name", &self.display_name);
1653 debug_struct.field("r#type", &self.r#type);
1654 debug_struct.field("is_required", &self.is_required);
1655 debug_struct.field("description", &self.description);
1656 debug_struct.field("order", &self.order);
1657 if !self._unknown_fields.is_empty() {
1658 debug_struct.field("_unknown_fields", &self._unknown_fields);
1659 }
1660 debug_struct.finish()
1661 }
1662}
1663
1664impl std::fmt::Debug for super::FieldType {
1665 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1666 let mut debug_struct = f.debug_struct("FieldType");
1667 debug_struct.field("type_decl", &self.type_decl);
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::field_type::EnumType {
1676 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1677 let mut debug_struct = f.debug_struct("EnumType");
1678 debug_struct.field("allowed_values", &self.allowed_values);
1679 if !self._unknown_fields.is_empty() {
1680 debug_struct.field("_unknown_fields", &self._unknown_fields);
1681 }
1682 debug_struct.finish()
1683 }
1684}
1685
1686impl std::fmt::Debug for super::field_type::enum_type::EnumValue {
1687 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1688 let mut debug_struct = f.debug_struct("EnumValue");
1689 debug_struct.field("display_name", &self.display_name);
1690 if !self._unknown_fields.is_empty() {
1691 debug_struct.field("_unknown_fields", &self._unknown_fields);
1692 }
1693 debug_struct.finish()
1694 }
1695}
1696
1697impl std::fmt::Debug for super::SystemTimestamps {
1698 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1699 let mut debug_struct = f.debug_struct("SystemTimestamps");
1700 debug_struct.field("create_time", &self.create_time);
1701 debug_struct.field("update_time", &self.update_time);
1702 debug_struct.field("expire_time", &self.expire_time);
1703 if !self._unknown_fields.is_empty() {
1704 debug_struct.field("_unknown_fields", &self._unknown_fields);
1705 }
1706 debug_struct.finish()
1707 }
1708}
1709
1710impl std::fmt::Debug for super::UsageStats {
1711 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1712 let mut debug_struct = f.debug_struct("UsageStats");
1713 debug_struct.field("total_completions", &self.total_completions);
1714 debug_struct.field("total_failures", &self.total_failures);
1715 debug_struct.field("total_cancellations", &self.total_cancellations);
1716 debug_struct.field(
1717 "total_execution_time_for_completions_millis",
1718 &self.total_execution_time_for_completions_millis,
1719 );
1720 if !self._unknown_fields.is_empty() {
1721 debug_struct.field("_unknown_fields", &self._unknown_fields);
1722 }
1723 debug_struct.finish()
1724 }
1725}
1726
1727impl std::fmt::Debug for super::CommonUsageStats {
1728 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1729 let mut debug_struct = f.debug_struct("CommonUsageStats");
1730 debug_struct.field("view_count", &self.view_count);
1731 if !self._unknown_fields.is_empty() {
1732 debug_struct.field("_unknown_fields", &self._unknown_fields);
1733 }
1734 debug_struct.finish()
1735 }
1736}
1737
1738impl std::fmt::Debug for super::UsageSignal {
1739 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1740 let mut debug_struct = f.debug_struct("UsageSignal");
1741 debug_struct.field("update_time", &self.update_time);
1742 debug_struct.field("usage_within_time_range", &self.usage_within_time_range);
1743 debug_struct.field(
1744 "common_usage_within_time_range",
1745 &self.common_usage_within_time_range,
1746 );
1747 debug_struct.field("favorite_count", &self.favorite_count);
1748 if !self._unknown_fields.is_empty() {
1749 debug_struct.field("_unknown_fields", &self._unknown_fields);
1750 }
1751 debug_struct.finish()
1752 }
1753}