1#![allow(rustdoc::broken_intra_doc_links)]
26
27pub(crate) mod dynamic;
28
29pub trait AddressGroupService: std::fmt::Debug + Send + Sync {
41 fn list_address_groups(
43 &self,
44 _req: crate::model::ListAddressGroupsRequest,
45 _options: crate::RequestOptions,
46 ) -> impl std::future::Future<
47 Output = crate::Result<crate::Response<crate::model::ListAddressGroupsResponse>>,
48 > + Send {
49 gaxi::unimplemented::unimplemented_stub()
50 }
51
52 fn get_address_group(
54 &self,
55 _req: crate::model::GetAddressGroupRequest,
56 _options: crate::RequestOptions,
57 ) -> impl std::future::Future<
58 Output = crate::Result<crate::Response<crate::model::AddressGroup>>,
59 > + Send {
60 gaxi::unimplemented::unimplemented_stub()
61 }
62
63 fn create_address_group(
65 &self,
66 _req: crate::model::CreateAddressGroupRequest,
67 _options: crate::RequestOptions,
68 ) -> impl std::future::Future<
69 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
70 > + Send {
71 gaxi::unimplemented::unimplemented_stub()
72 }
73
74 fn update_address_group(
76 &self,
77 _req: crate::model::UpdateAddressGroupRequest,
78 _options: crate::RequestOptions,
79 ) -> impl std::future::Future<
80 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
81 > + Send {
82 gaxi::unimplemented::unimplemented_stub()
83 }
84
85 fn add_address_group_items(
87 &self,
88 _req: crate::model::AddAddressGroupItemsRequest,
89 _options: crate::RequestOptions,
90 ) -> impl std::future::Future<
91 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
92 > + Send {
93 gaxi::unimplemented::unimplemented_stub()
94 }
95
96 fn remove_address_group_items(
98 &self,
99 _req: crate::model::RemoveAddressGroupItemsRequest,
100 _options: crate::RequestOptions,
101 ) -> impl std::future::Future<
102 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
103 > + Send {
104 gaxi::unimplemented::unimplemented_stub()
105 }
106
107 fn clone_address_group_items(
109 &self,
110 _req: crate::model::CloneAddressGroupItemsRequest,
111 _options: crate::RequestOptions,
112 ) -> impl std::future::Future<
113 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
114 > + Send {
115 gaxi::unimplemented::unimplemented_stub()
116 }
117
118 fn delete_address_group(
120 &self,
121 _req: crate::model::DeleteAddressGroupRequest,
122 _options: crate::RequestOptions,
123 ) -> impl std::future::Future<
124 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
125 > + Send {
126 gaxi::unimplemented::unimplemented_stub()
127 }
128
129 fn list_address_group_references(
131 &self,
132 _req: crate::model::ListAddressGroupReferencesRequest,
133 _options: crate::RequestOptions,
134 ) -> impl std::future::Future<
135 Output = crate::Result<crate::Response<crate::model::ListAddressGroupReferencesResponse>>,
136 > + Send {
137 gaxi::unimplemented::unimplemented_stub()
138 }
139
140 fn list_locations(
142 &self,
143 _req: google_cloud_location::model::ListLocationsRequest,
144 _options: crate::RequestOptions,
145 ) -> impl std::future::Future<
146 Output = crate::Result<
147 crate::Response<google_cloud_location::model::ListLocationsResponse>,
148 >,
149 > + Send {
150 gaxi::unimplemented::unimplemented_stub()
151 }
152
153 fn get_location(
155 &self,
156 _req: google_cloud_location::model::GetLocationRequest,
157 _options: crate::RequestOptions,
158 ) -> impl std::future::Future<
159 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
160 > + Send {
161 gaxi::unimplemented::unimplemented_stub()
162 }
163
164 fn set_iam_policy(
166 &self,
167 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
168 _options: crate::RequestOptions,
169 ) -> impl std::future::Future<
170 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
171 > + Send {
172 gaxi::unimplemented::unimplemented_stub()
173 }
174
175 fn get_iam_policy(
177 &self,
178 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
179 _options: crate::RequestOptions,
180 ) -> impl std::future::Future<
181 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
182 > + Send {
183 gaxi::unimplemented::unimplemented_stub()
184 }
185
186 fn test_iam_permissions(
188 &self,
189 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
190 _options: crate::RequestOptions,
191 ) -> impl std::future::Future<
192 Output = crate::Result<
193 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
194 >,
195 > + Send {
196 gaxi::unimplemented::unimplemented_stub()
197 }
198
199 fn list_operations(
201 &self,
202 _req: google_cloud_longrunning::model::ListOperationsRequest,
203 _options: crate::RequestOptions,
204 ) -> impl std::future::Future<
205 Output = crate::Result<
206 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
207 >,
208 > + Send {
209 gaxi::unimplemented::unimplemented_stub()
210 }
211
212 fn get_operation(
214 &self,
215 _req: google_cloud_longrunning::model::GetOperationRequest,
216 _options: crate::RequestOptions,
217 ) -> impl std::future::Future<
218 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
219 > + Send {
220 gaxi::unimplemented::unimplemented_stub()
221 }
222
223 fn delete_operation(
225 &self,
226 _req: google_cloud_longrunning::model::DeleteOperationRequest,
227 _options: crate::RequestOptions,
228 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
229 gaxi::unimplemented::unimplemented_stub()
230 }
231
232 fn cancel_operation(
234 &self,
235 _req: google_cloud_longrunning::model::CancelOperationRequest,
236 _options: crate::RequestOptions,
237 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
238 gaxi::unimplemented::unimplemented_stub()
239 }
240
241 fn get_polling_error_policy(
246 &self,
247 _options: &crate::RequestOptions,
248 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
249 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
250 }
251
252 fn get_polling_backoff_policy(
257 &self,
258 _options: &crate::RequestOptions,
259 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
260 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
261 }
262
263 #[doc(hidden)]
264 fn get_poller_options(
269 &self,
270 _options: &crate::RequestOptions,
271 ) -> google_cloud_lro::PollerOptions {
272 google_cloud_lro::PollerOptions::default()
273 }
274}
275
276pub trait OrganizationAddressGroupService: std::fmt::Debug + Send + Sync {
288 fn list_address_groups(
290 &self,
291 _req: crate::model::ListAddressGroupsRequest,
292 _options: crate::RequestOptions,
293 ) -> impl std::future::Future<
294 Output = crate::Result<crate::Response<crate::model::ListAddressGroupsResponse>>,
295 > + Send {
296 gaxi::unimplemented::unimplemented_stub()
297 }
298
299 fn get_address_group(
301 &self,
302 _req: crate::model::GetAddressGroupRequest,
303 _options: crate::RequestOptions,
304 ) -> impl std::future::Future<
305 Output = crate::Result<crate::Response<crate::model::AddressGroup>>,
306 > + Send {
307 gaxi::unimplemented::unimplemented_stub()
308 }
309
310 fn create_address_group(
312 &self,
313 _req: crate::model::CreateAddressGroupRequest,
314 _options: crate::RequestOptions,
315 ) -> impl std::future::Future<
316 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
317 > + Send {
318 gaxi::unimplemented::unimplemented_stub()
319 }
320
321 fn update_address_group(
323 &self,
324 _req: crate::model::UpdateAddressGroupRequest,
325 _options: crate::RequestOptions,
326 ) -> impl std::future::Future<
327 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
328 > + Send {
329 gaxi::unimplemented::unimplemented_stub()
330 }
331
332 fn add_address_group_items(
334 &self,
335 _req: crate::model::AddAddressGroupItemsRequest,
336 _options: crate::RequestOptions,
337 ) -> impl std::future::Future<
338 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
339 > + Send {
340 gaxi::unimplemented::unimplemented_stub()
341 }
342
343 fn remove_address_group_items(
345 &self,
346 _req: crate::model::RemoveAddressGroupItemsRequest,
347 _options: crate::RequestOptions,
348 ) -> impl std::future::Future<
349 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
350 > + Send {
351 gaxi::unimplemented::unimplemented_stub()
352 }
353
354 fn clone_address_group_items(
356 &self,
357 _req: crate::model::CloneAddressGroupItemsRequest,
358 _options: crate::RequestOptions,
359 ) -> impl std::future::Future<
360 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
361 > + Send {
362 gaxi::unimplemented::unimplemented_stub()
363 }
364
365 fn delete_address_group(
367 &self,
368 _req: crate::model::DeleteAddressGroupRequest,
369 _options: crate::RequestOptions,
370 ) -> impl std::future::Future<
371 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
372 > + Send {
373 gaxi::unimplemented::unimplemented_stub()
374 }
375
376 fn list_address_group_references(
378 &self,
379 _req: crate::model::ListAddressGroupReferencesRequest,
380 _options: crate::RequestOptions,
381 ) -> impl std::future::Future<
382 Output = crate::Result<crate::Response<crate::model::ListAddressGroupReferencesResponse>>,
383 > + Send {
384 gaxi::unimplemented::unimplemented_stub()
385 }
386
387 fn list_locations(
389 &self,
390 _req: google_cloud_location::model::ListLocationsRequest,
391 _options: crate::RequestOptions,
392 ) -> impl std::future::Future<
393 Output = crate::Result<
394 crate::Response<google_cloud_location::model::ListLocationsResponse>,
395 >,
396 > + Send {
397 gaxi::unimplemented::unimplemented_stub()
398 }
399
400 fn get_location(
402 &self,
403 _req: google_cloud_location::model::GetLocationRequest,
404 _options: crate::RequestOptions,
405 ) -> impl std::future::Future<
406 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
407 > + Send {
408 gaxi::unimplemented::unimplemented_stub()
409 }
410
411 fn set_iam_policy(
413 &self,
414 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
415 _options: crate::RequestOptions,
416 ) -> impl std::future::Future<
417 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
418 > + Send {
419 gaxi::unimplemented::unimplemented_stub()
420 }
421
422 fn get_iam_policy(
424 &self,
425 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
426 _options: crate::RequestOptions,
427 ) -> impl std::future::Future<
428 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
429 > + Send {
430 gaxi::unimplemented::unimplemented_stub()
431 }
432
433 fn test_iam_permissions(
435 &self,
436 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
437 _options: crate::RequestOptions,
438 ) -> impl std::future::Future<
439 Output = crate::Result<
440 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
441 >,
442 > + Send {
443 gaxi::unimplemented::unimplemented_stub()
444 }
445
446 fn list_operations(
448 &self,
449 _req: google_cloud_longrunning::model::ListOperationsRequest,
450 _options: crate::RequestOptions,
451 ) -> impl std::future::Future<
452 Output = crate::Result<
453 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
454 >,
455 > + Send {
456 gaxi::unimplemented::unimplemented_stub()
457 }
458
459 fn get_operation(
461 &self,
462 _req: google_cloud_longrunning::model::GetOperationRequest,
463 _options: crate::RequestOptions,
464 ) -> impl std::future::Future<
465 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
466 > + Send {
467 gaxi::unimplemented::unimplemented_stub()
468 }
469
470 fn delete_operation(
472 &self,
473 _req: google_cloud_longrunning::model::DeleteOperationRequest,
474 _options: crate::RequestOptions,
475 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
476 gaxi::unimplemented::unimplemented_stub()
477 }
478
479 fn cancel_operation(
481 &self,
482 _req: google_cloud_longrunning::model::CancelOperationRequest,
483 _options: crate::RequestOptions,
484 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
485 gaxi::unimplemented::unimplemented_stub()
486 }
487
488 fn get_polling_error_policy(
493 &self,
494 _options: &crate::RequestOptions,
495 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
496 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
497 }
498
499 fn get_polling_backoff_policy(
504 &self,
505 _options: &crate::RequestOptions,
506 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
507 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
508 }
509
510 #[doc(hidden)]
511 fn get_poller_options(
516 &self,
517 _options: &crate::RequestOptions,
518 ) -> google_cloud_lro::PollerOptions {
519 google_cloud_lro::PollerOptions::default()
520 }
521}
522
523pub trait DnsThreatDetectorService: std::fmt::Debug + Send + Sync {
535 fn list_dns_threat_detectors(
537 &self,
538 _req: crate::model::ListDnsThreatDetectorsRequest,
539 _options: crate::RequestOptions,
540 ) -> impl std::future::Future<
541 Output = crate::Result<crate::Response<crate::model::ListDnsThreatDetectorsResponse>>,
542 > + Send {
543 gaxi::unimplemented::unimplemented_stub()
544 }
545
546 fn get_dns_threat_detector(
548 &self,
549 _req: crate::model::GetDnsThreatDetectorRequest,
550 _options: crate::RequestOptions,
551 ) -> impl std::future::Future<
552 Output = crate::Result<crate::Response<crate::model::DnsThreatDetector>>,
553 > + Send {
554 gaxi::unimplemented::unimplemented_stub()
555 }
556
557 fn create_dns_threat_detector(
559 &self,
560 _req: crate::model::CreateDnsThreatDetectorRequest,
561 _options: crate::RequestOptions,
562 ) -> impl std::future::Future<
563 Output = crate::Result<crate::Response<crate::model::DnsThreatDetector>>,
564 > + Send {
565 gaxi::unimplemented::unimplemented_stub()
566 }
567
568 fn update_dns_threat_detector(
570 &self,
571 _req: crate::model::UpdateDnsThreatDetectorRequest,
572 _options: crate::RequestOptions,
573 ) -> impl std::future::Future<
574 Output = crate::Result<crate::Response<crate::model::DnsThreatDetector>>,
575 > + Send {
576 gaxi::unimplemented::unimplemented_stub()
577 }
578
579 fn delete_dns_threat_detector(
581 &self,
582 _req: crate::model::DeleteDnsThreatDetectorRequest,
583 _options: crate::RequestOptions,
584 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
585 gaxi::unimplemented::unimplemented_stub()
586 }
587
588 fn list_locations(
590 &self,
591 _req: google_cloud_location::model::ListLocationsRequest,
592 _options: crate::RequestOptions,
593 ) -> impl std::future::Future<
594 Output = crate::Result<
595 crate::Response<google_cloud_location::model::ListLocationsResponse>,
596 >,
597 > + Send {
598 gaxi::unimplemented::unimplemented_stub()
599 }
600
601 fn get_location(
603 &self,
604 _req: google_cloud_location::model::GetLocationRequest,
605 _options: crate::RequestOptions,
606 ) -> impl std::future::Future<
607 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
608 > + Send {
609 gaxi::unimplemented::unimplemented_stub()
610 }
611
612 fn set_iam_policy(
614 &self,
615 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
616 _options: crate::RequestOptions,
617 ) -> impl std::future::Future<
618 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
619 > + Send {
620 gaxi::unimplemented::unimplemented_stub()
621 }
622
623 fn get_iam_policy(
625 &self,
626 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
627 _options: crate::RequestOptions,
628 ) -> impl std::future::Future<
629 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
630 > + Send {
631 gaxi::unimplemented::unimplemented_stub()
632 }
633
634 fn test_iam_permissions(
636 &self,
637 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
638 _options: crate::RequestOptions,
639 ) -> impl std::future::Future<
640 Output = crate::Result<
641 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
642 >,
643 > + Send {
644 gaxi::unimplemented::unimplemented_stub()
645 }
646
647 fn list_operations(
649 &self,
650 _req: google_cloud_longrunning::model::ListOperationsRequest,
651 _options: crate::RequestOptions,
652 ) -> impl std::future::Future<
653 Output = crate::Result<
654 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
655 >,
656 > + Send {
657 gaxi::unimplemented::unimplemented_stub()
658 }
659
660 fn get_operation(
662 &self,
663 _req: google_cloud_longrunning::model::GetOperationRequest,
664 _options: crate::RequestOptions,
665 ) -> impl std::future::Future<
666 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
667 > + Send {
668 gaxi::unimplemented::unimplemented_stub()
669 }
670
671 fn delete_operation(
673 &self,
674 _req: google_cloud_longrunning::model::DeleteOperationRequest,
675 _options: crate::RequestOptions,
676 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
677 gaxi::unimplemented::unimplemented_stub()
678 }
679
680 fn cancel_operation(
682 &self,
683 _req: google_cloud_longrunning::model::CancelOperationRequest,
684 _options: crate::RequestOptions,
685 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
686 gaxi::unimplemented::unimplemented_stub()
687 }
688}
689
690pub trait FirewallActivation: std::fmt::Debug + Send + Sync {
702 fn list_firewall_endpoints(
704 &self,
705 _req: crate::model::ListFirewallEndpointsRequest,
706 _options: crate::RequestOptions,
707 ) -> impl std::future::Future<
708 Output = crate::Result<crate::Response<crate::model::ListFirewallEndpointsResponse>>,
709 > + Send {
710 gaxi::unimplemented::unimplemented_stub()
711 }
712
713 fn list_project_firewall_endpoints(
715 &self,
716 _req: crate::model::ListFirewallEndpointsRequest,
717 _options: crate::RequestOptions,
718 ) -> impl std::future::Future<
719 Output = crate::Result<crate::Response<crate::model::ListFirewallEndpointsResponse>>,
720 > + Send {
721 gaxi::unimplemented::unimplemented_stub()
722 }
723
724 fn get_firewall_endpoint(
726 &self,
727 _req: crate::model::GetFirewallEndpointRequest,
728 _options: crate::RequestOptions,
729 ) -> impl std::future::Future<
730 Output = crate::Result<crate::Response<crate::model::FirewallEndpoint>>,
731 > + Send {
732 gaxi::unimplemented::unimplemented_stub()
733 }
734
735 fn get_project_firewall_endpoint(
737 &self,
738 _req: crate::model::GetFirewallEndpointRequest,
739 _options: crate::RequestOptions,
740 ) -> impl std::future::Future<
741 Output = crate::Result<crate::Response<crate::model::FirewallEndpoint>>,
742 > + Send {
743 gaxi::unimplemented::unimplemented_stub()
744 }
745
746 fn create_firewall_endpoint(
748 &self,
749 _req: crate::model::CreateFirewallEndpointRequest,
750 _options: crate::RequestOptions,
751 ) -> impl std::future::Future<
752 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
753 > + Send {
754 gaxi::unimplemented::unimplemented_stub()
755 }
756
757 fn create_project_firewall_endpoint(
759 &self,
760 _req: crate::model::CreateFirewallEndpointRequest,
761 _options: crate::RequestOptions,
762 ) -> impl std::future::Future<
763 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
764 > + Send {
765 gaxi::unimplemented::unimplemented_stub()
766 }
767
768 fn delete_firewall_endpoint(
770 &self,
771 _req: crate::model::DeleteFirewallEndpointRequest,
772 _options: crate::RequestOptions,
773 ) -> impl std::future::Future<
774 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
775 > + Send {
776 gaxi::unimplemented::unimplemented_stub()
777 }
778
779 fn delete_project_firewall_endpoint(
781 &self,
782 _req: crate::model::DeleteFirewallEndpointRequest,
783 _options: crate::RequestOptions,
784 ) -> impl std::future::Future<
785 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
786 > + Send {
787 gaxi::unimplemented::unimplemented_stub()
788 }
789
790 fn update_firewall_endpoint(
792 &self,
793 _req: crate::model::UpdateFirewallEndpointRequest,
794 _options: crate::RequestOptions,
795 ) -> impl std::future::Future<
796 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
797 > + Send {
798 gaxi::unimplemented::unimplemented_stub()
799 }
800
801 fn update_project_firewall_endpoint(
803 &self,
804 _req: crate::model::UpdateFirewallEndpointRequest,
805 _options: crate::RequestOptions,
806 ) -> impl std::future::Future<
807 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
808 > + Send {
809 gaxi::unimplemented::unimplemented_stub()
810 }
811
812 fn list_firewall_endpoint_associations(
814 &self,
815 _req: crate::model::ListFirewallEndpointAssociationsRequest,
816 _options: crate::RequestOptions,
817 ) -> impl std::future::Future<
818 Output = crate::Result<
819 crate::Response<crate::model::ListFirewallEndpointAssociationsResponse>,
820 >,
821 > + Send {
822 gaxi::unimplemented::unimplemented_stub()
823 }
824
825 fn get_firewall_endpoint_association(
827 &self,
828 _req: crate::model::GetFirewallEndpointAssociationRequest,
829 _options: crate::RequestOptions,
830 ) -> impl std::future::Future<
831 Output = crate::Result<crate::Response<crate::model::FirewallEndpointAssociation>>,
832 > + Send {
833 gaxi::unimplemented::unimplemented_stub()
834 }
835
836 fn create_firewall_endpoint_association(
838 &self,
839 _req: crate::model::CreateFirewallEndpointAssociationRequest,
840 _options: crate::RequestOptions,
841 ) -> impl std::future::Future<
842 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
843 > + Send {
844 gaxi::unimplemented::unimplemented_stub()
845 }
846
847 fn delete_firewall_endpoint_association(
849 &self,
850 _req: crate::model::DeleteFirewallEndpointAssociationRequest,
851 _options: crate::RequestOptions,
852 ) -> impl std::future::Future<
853 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
854 > + Send {
855 gaxi::unimplemented::unimplemented_stub()
856 }
857
858 fn update_firewall_endpoint_association(
860 &self,
861 _req: crate::model::UpdateFirewallEndpointAssociationRequest,
862 _options: crate::RequestOptions,
863 ) -> impl std::future::Future<
864 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
865 > + Send {
866 gaxi::unimplemented::unimplemented_stub()
867 }
868
869 fn list_locations(
871 &self,
872 _req: google_cloud_location::model::ListLocationsRequest,
873 _options: crate::RequestOptions,
874 ) -> impl std::future::Future<
875 Output = crate::Result<
876 crate::Response<google_cloud_location::model::ListLocationsResponse>,
877 >,
878 > + Send {
879 gaxi::unimplemented::unimplemented_stub()
880 }
881
882 fn get_location(
884 &self,
885 _req: google_cloud_location::model::GetLocationRequest,
886 _options: crate::RequestOptions,
887 ) -> impl std::future::Future<
888 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
889 > + Send {
890 gaxi::unimplemented::unimplemented_stub()
891 }
892
893 fn set_iam_policy(
895 &self,
896 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
897 _options: crate::RequestOptions,
898 ) -> impl std::future::Future<
899 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
900 > + Send {
901 gaxi::unimplemented::unimplemented_stub()
902 }
903
904 fn get_iam_policy(
906 &self,
907 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
908 _options: crate::RequestOptions,
909 ) -> impl std::future::Future<
910 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
911 > + Send {
912 gaxi::unimplemented::unimplemented_stub()
913 }
914
915 fn test_iam_permissions(
917 &self,
918 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
919 _options: crate::RequestOptions,
920 ) -> impl std::future::Future<
921 Output = crate::Result<
922 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
923 >,
924 > + Send {
925 gaxi::unimplemented::unimplemented_stub()
926 }
927
928 fn list_operations(
930 &self,
931 _req: google_cloud_longrunning::model::ListOperationsRequest,
932 _options: crate::RequestOptions,
933 ) -> impl std::future::Future<
934 Output = crate::Result<
935 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
936 >,
937 > + Send {
938 gaxi::unimplemented::unimplemented_stub()
939 }
940
941 fn get_operation(
943 &self,
944 _req: google_cloud_longrunning::model::GetOperationRequest,
945 _options: crate::RequestOptions,
946 ) -> impl std::future::Future<
947 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
948 > + Send {
949 gaxi::unimplemented::unimplemented_stub()
950 }
951
952 fn delete_operation(
954 &self,
955 _req: google_cloud_longrunning::model::DeleteOperationRequest,
956 _options: crate::RequestOptions,
957 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
958 gaxi::unimplemented::unimplemented_stub()
959 }
960
961 fn cancel_operation(
963 &self,
964 _req: google_cloud_longrunning::model::CancelOperationRequest,
965 _options: crate::RequestOptions,
966 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
967 gaxi::unimplemented::unimplemented_stub()
968 }
969
970 fn get_polling_error_policy(
975 &self,
976 _options: &crate::RequestOptions,
977 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
978 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
979 }
980
981 fn get_polling_backoff_policy(
986 &self,
987 _options: &crate::RequestOptions,
988 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
989 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
990 }
991
992 #[doc(hidden)]
993 fn get_poller_options(
998 &self,
999 _options: &crate::RequestOptions,
1000 ) -> google_cloud_lro::PollerOptions {
1001 google_cloud_lro::PollerOptions::default()
1002 }
1003}
1004
1005pub trait Intercept: std::fmt::Debug + Send + Sync {
1017 fn list_intercept_endpoint_groups(
1019 &self,
1020 _req: crate::model::ListInterceptEndpointGroupsRequest,
1021 _options: crate::RequestOptions,
1022 ) -> impl std::future::Future<
1023 Output = crate::Result<crate::Response<crate::model::ListInterceptEndpointGroupsResponse>>,
1024 > + Send {
1025 gaxi::unimplemented::unimplemented_stub()
1026 }
1027
1028 fn get_intercept_endpoint_group(
1030 &self,
1031 _req: crate::model::GetInterceptEndpointGroupRequest,
1032 _options: crate::RequestOptions,
1033 ) -> impl std::future::Future<
1034 Output = crate::Result<crate::Response<crate::model::InterceptEndpointGroup>>,
1035 > + Send {
1036 gaxi::unimplemented::unimplemented_stub()
1037 }
1038
1039 fn create_intercept_endpoint_group(
1041 &self,
1042 _req: crate::model::CreateInterceptEndpointGroupRequest,
1043 _options: crate::RequestOptions,
1044 ) -> impl std::future::Future<
1045 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1046 > + Send {
1047 gaxi::unimplemented::unimplemented_stub()
1048 }
1049
1050 fn update_intercept_endpoint_group(
1052 &self,
1053 _req: crate::model::UpdateInterceptEndpointGroupRequest,
1054 _options: crate::RequestOptions,
1055 ) -> impl std::future::Future<
1056 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1057 > + Send {
1058 gaxi::unimplemented::unimplemented_stub()
1059 }
1060
1061 fn delete_intercept_endpoint_group(
1063 &self,
1064 _req: crate::model::DeleteInterceptEndpointGroupRequest,
1065 _options: crate::RequestOptions,
1066 ) -> impl std::future::Future<
1067 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1068 > + Send {
1069 gaxi::unimplemented::unimplemented_stub()
1070 }
1071
1072 fn list_intercept_endpoint_group_associations(
1074 &self,
1075 _req: crate::model::ListInterceptEndpointGroupAssociationsRequest,
1076 _options: crate::RequestOptions,
1077 ) -> impl std::future::Future<
1078 Output = crate::Result<
1079 crate::Response<crate::model::ListInterceptEndpointGroupAssociationsResponse>,
1080 >,
1081 > + Send {
1082 gaxi::unimplemented::unimplemented_stub()
1083 }
1084
1085 fn get_intercept_endpoint_group_association(
1087 &self,
1088 _req: crate::model::GetInterceptEndpointGroupAssociationRequest,
1089 _options: crate::RequestOptions,
1090 ) -> impl std::future::Future<
1091 Output = crate::Result<crate::Response<crate::model::InterceptEndpointGroupAssociation>>,
1092 > + Send {
1093 gaxi::unimplemented::unimplemented_stub()
1094 }
1095
1096 fn create_intercept_endpoint_group_association(
1098 &self,
1099 _req: crate::model::CreateInterceptEndpointGroupAssociationRequest,
1100 _options: crate::RequestOptions,
1101 ) -> impl std::future::Future<
1102 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1103 > + Send {
1104 gaxi::unimplemented::unimplemented_stub()
1105 }
1106
1107 fn update_intercept_endpoint_group_association(
1109 &self,
1110 _req: crate::model::UpdateInterceptEndpointGroupAssociationRequest,
1111 _options: crate::RequestOptions,
1112 ) -> impl std::future::Future<
1113 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1114 > + Send {
1115 gaxi::unimplemented::unimplemented_stub()
1116 }
1117
1118 fn delete_intercept_endpoint_group_association(
1120 &self,
1121 _req: crate::model::DeleteInterceptEndpointGroupAssociationRequest,
1122 _options: crate::RequestOptions,
1123 ) -> impl std::future::Future<
1124 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1125 > + Send {
1126 gaxi::unimplemented::unimplemented_stub()
1127 }
1128
1129 fn list_intercept_deployment_groups(
1131 &self,
1132 _req: crate::model::ListInterceptDeploymentGroupsRequest,
1133 _options: crate::RequestOptions,
1134 ) -> impl std::future::Future<
1135 Output = crate::Result<
1136 crate::Response<crate::model::ListInterceptDeploymentGroupsResponse>,
1137 >,
1138 > + Send {
1139 gaxi::unimplemented::unimplemented_stub()
1140 }
1141
1142 fn get_intercept_deployment_group(
1144 &self,
1145 _req: crate::model::GetInterceptDeploymentGroupRequest,
1146 _options: crate::RequestOptions,
1147 ) -> impl std::future::Future<
1148 Output = crate::Result<crate::Response<crate::model::InterceptDeploymentGroup>>,
1149 > + Send {
1150 gaxi::unimplemented::unimplemented_stub()
1151 }
1152
1153 fn create_intercept_deployment_group(
1155 &self,
1156 _req: crate::model::CreateInterceptDeploymentGroupRequest,
1157 _options: crate::RequestOptions,
1158 ) -> impl std::future::Future<
1159 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1160 > + Send {
1161 gaxi::unimplemented::unimplemented_stub()
1162 }
1163
1164 fn update_intercept_deployment_group(
1166 &self,
1167 _req: crate::model::UpdateInterceptDeploymentGroupRequest,
1168 _options: crate::RequestOptions,
1169 ) -> impl std::future::Future<
1170 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1171 > + Send {
1172 gaxi::unimplemented::unimplemented_stub()
1173 }
1174
1175 fn delete_intercept_deployment_group(
1177 &self,
1178 _req: crate::model::DeleteInterceptDeploymentGroupRequest,
1179 _options: crate::RequestOptions,
1180 ) -> impl std::future::Future<
1181 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1182 > + Send {
1183 gaxi::unimplemented::unimplemented_stub()
1184 }
1185
1186 fn list_intercept_deployments(
1188 &self,
1189 _req: crate::model::ListInterceptDeploymentsRequest,
1190 _options: crate::RequestOptions,
1191 ) -> impl std::future::Future<
1192 Output = crate::Result<crate::Response<crate::model::ListInterceptDeploymentsResponse>>,
1193 > + Send {
1194 gaxi::unimplemented::unimplemented_stub()
1195 }
1196
1197 fn get_intercept_deployment(
1199 &self,
1200 _req: crate::model::GetInterceptDeploymentRequest,
1201 _options: crate::RequestOptions,
1202 ) -> impl std::future::Future<
1203 Output = crate::Result<crate::Response<crate::model::InterceptDeployment>>,
1204 > + Send {
1205 gaxi::unimplemented::unimplemented_stub()
1206 }
1207
1208 fn create_intercept_deployment(
1210 &self,
1211 _req: crate::model::CreateInterceptDeploymentRequest,
1212 _options: crate::RequestOptions,
1213 ) -> impl std::future::Future<
1214 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1215 > + Send {
1216 gaxi::unimplemented::unimplemented_stub()
1217 }
1218
1219 fn update_intercept_deployment(
1221 &self,
1222 _req: crate::model::UpdateInterceptDeploymentRequest,
1223 _options: crate::RequestOptions,
1224 ) -> impl std::future::Future<
1225 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1226 > + Send {
1227 gaxi::unimplemented::unimplemented_stub()
1228 }
1229
1230 fn delete_intercept_deployment(
1232 &self,
1233 _req: crate::model::DeleteInterceptDeploymentRequest,
1234 _options: crate::RequestOptions,
1235 ) -> impl std::future::Future<
1236 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1237 > + Send {
1238 gaxi::unimplemented::unimplemented_stub()
1239 }
1240
1241 fn list_locations(
1243 &self,
1244 _req: google_cloud_location::model::ListLocationsRequest,
1245 _options: crate::RequestOptions,
1246 ) -> impl std::future::Future<
1247 Output = crate::Result<
1248 crate::Response<google_cloud_location::model::ListLocationsResponse>,
1249 >,
1250 > + Send {
1251 gaxi::unimplemented::unimplemented_stub()
1252 }
1253
1254 fn get_location(
1256 &self,
1257 _req: google_cloud_location::model::GetLocationRequest,
1258 _options: crate::RequestOptions,
1259 ) -> impl std::future::Future<
1260 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
1261 > + Send {
1262 gaxi::unimplemented::unimplemented_stub()
1263 }
1264
1265 fn set_iam_policy(
1267 &self,
1268 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
1269 _options: crate::RequestOptions,
1270 ) -> impl std::future::Future<
1271 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
1272 > + Send {
1273 gaxi::unimplemented::unimplemented_stub()
1274 }
1275
1276 fn get_iam_policy(
1278 &self,
1279 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
1280 _options: crate::RequestOptions,
1281 ) -> impl std::future::Future<
1282 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
1283 > + Send {
1284 gaxi::unimplemented::unimplemented_stub()
1285 }
1286
1287 fn test_iam_permissions(
1289 &self,
1290 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
1291 _options: crate::RequestOptions,
1292 ) -> impl std::future::Future<
1293 Output = crate::Result<
1294 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
1295 >,
1296 > + Send {
1297 gaxi::unimplemented::unimplemented_stub()
1298 }
1299
1300 fn list_operations(
1302 &self,
1303 _req: google_cloud_longrunning::model::ListOperationsRequest,
1304 _options: crate::RequestOptions,
1305 ) -> impl std::future::Future<
1306 Output = crate::Result<
1307 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
1308 >,
1309 > + Send {
1310 gaxi::unimplemented::unimplemented_stub()
1311 }
1312
1313 fn get_operation(
1315 &self,
1316 _req: google_cloud_longrunning::model::GetOperationRequest,
1317 _options: crate::RequestOptions,
1318 ) -> impl std::future::Future<
1319 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1320 > + Send {
1321 gaxi::unimplemented::unimplemented_stub()
1322 }
1323
1324 fn delete_operation(
1326 &self,
1327 _req: google_cloud_longrunning::model::DeleteOperationRequest,
1328 _options: crate::RequestOptions,
1329 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
1330 gaxi::unimplemented::unimplemented_stub()
1331 }
1332
1333 fn cancel_operation(
1335 &self,
1336 _req: google_cloud_longrunning::model::CancelOperationRequest,
1337 _options: crate::RequestOptions,
1338 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
1339 gaxi::unimplemented::unimplemented_stub()
1340 }
1341
1342 fn get_polling_error_policy(
1347 &self,
1348 _options: &crate::RequestOptions,
1349 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
1350 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
1351 }
1352
1353 fn get_polling_backoff_policy(
1358 &self,
1359 _options: &crate::RequestOptions,
1360 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
1361 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
1362 }
1363
1364 #[doc(hidden)]
1365 fn get_poller_options(
1370 &self,
1371 _options: &crate::RequestOptions,
1372 ) -> google_cloud_lro::PollerOptions {
1373 google_cloud_lro::PollerOptions::default()
1374 }
1375}
1376
1377pub trait Mirroring: std::fmt::Debug + Send + Sync {
1389 fn list_mirroring_endpoint_groups(
1391 &self,
1392 _req: crate::model::ListMirroringEndpointGroupsRequest,
1393 _options: crate::RequestOptions,
1394 ) -> impl std::future::Future<
1395 Output = crate::Result<crate::Response<crate::model::ListMirroringEndpointGroupsResponse>>,
1396 > + Send {
1397 gaxi::unimplemented::unimplemented_stub()
1398 }
1399
1400 fn get_mirroring_endpoint_group(
1402 &self,
1403 _req: crate::model::GetMirroringEndpointGroupRequest,
1404 _options: crate::RequestOptions,
1405 ) -> impl std::future::Future<
1406 Output = crate::Result<crate::Response<crate::model::MirroringEndpointGroup>>,
1407 > + Send {
1408 gaxi::unimplemented::unimplemented_stub()
1409 }
1410
1411 fn create_mirroring_endpoint_group(
1413 &self,
1414 _req: crate::model::CreateMirroringEndpointGroupRequest,
1415 _options: crate::RequestOptions,
1416 ) -> impl std::future::Future<
1417 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1418 > + Send {
1419 gaxi::unimplemented::unimplemented_stub()
1420 }
1421
1422 fn update_mirroring_endpoint_group(
1424 &self,
1425 _req: crate::model::UpdateMirroringEndpointGroupRequest,
1426 _options: crate::RequestOptions,
1427 ) -> impl std::future::Future<
1428 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1429 > + Send {
1430 gaxi::unimplemented::unimplemented_stub()
1431 }
1432
1433 fn delete_mirroring_endpoint_group(
1435 &self,
1436 _req: crate::model::DeleteMirroringEndpointGroupRequest,
1437 _options: crate::RequestOptions,
1438 ) -> impl std::future::Future<
1439 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1440 > + Send {
1441 gaxi::unimplemented::unimplemented_stub()
1442 }
1443
1444 fn list_mirroring_endpoint_group_associations(
1446 &self,
1447 _req: crate::model::ListMirroringEndpointGroupAssociationsRequest,
1448 _options: crate::RequestOptions,
1449 ) -> impl std::future::Future<
1450 Output = crate::Result<
1451 crate::Response<crate::model::ListMirroringEndpointGroupAssociationsResponse>,
1452 >,
1453 > + Send {
1454 gaxi::unimplemented::unimplemented_stub()
1455 }
1456
1457 fn get_mirroring_endpoint_group_association(
1459 &self,
1460 _req: crate::model::GetMirroringEndpointGroupAssociationRequest,
1461 _options: crate::RequestOptions,
1462 ) -> impl std::future::Future<
1463 Output = crate::Result<crate::Response<crate::model::MirroringEndpointGroupAssociation>>,
1464 > + Send {
1465 gaxi::unimplemented::unimplemented_stub()
1466 }
1467
1468 fn create_mirroring_endpoint_group_association(
1470 &self,
1471 _req: crate::model::CreateMirroringEndpointGroupAssociationRequest,
1472 _options: crate::RequestOptions,
1473 ) -> impl std::future::Future<
1474 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1475 > + Send {
1476 gaxi::unimplemented::unimplemented_stub()
1477 }
1478
1479 fn update_mirroring_endpoint_group_association(
1481 &self,
1482 _req: crate::model::UpdateMirroringEndpointGroupAssociationRequest,
1483 _options: crate::RequestOptions,
1484 ) -> impl std::future::Future<
1485 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1486 > + Send {
1487 gaxi::unimplemented::unimplemented_stub()
1488 }
1489
1490 fn delete_mirroring_endpoint_group_association(
1492 &self,
1493 _req: crate::model::DeleteMirroringEndpointGroupAssociationRequest,
1494 _options: crate::RequestOptions,
1495 ) -> impl std::future::Future<
1496 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1497 > + Send {
1498 gaxi::unimplemented::unimplemented_stub()
1499 }
1500
1501 fn list_mirroring_deployment_groups(
1503 &self,
1504 _req: crate::model::ListMirroringDeploymentGroupsRequest,
1505 _options: crate::RequestOptions,
1506 ) -> impl std::future::Future<
1507 Output = crate::Result<
1508 crate::Response<crate::model::ListMirroringDeploymentGroupsResponse>,
1509 >,
1510 > + Send {
1511 gaxi::unimplemented::unimplemented_stub()
1512 }
1513
1514 fn get_mirroring_deployment_group(
1516 &self,
1517 _req: crate::model::GetMirroringDeploymentGroupRequest,
1518 _options: crate::RequestOptions,
1519 ) -> impl std::future::Future<
1520 Output = crate::Result<crate::Response<crate::model::MirroringDeploymentGroup>>,
1521 > + Send {
1522 gaxi::unimplemented::unimplemented_stub()
1523 }
1524
1525 fn create_mirroring_deployment_group(
1527 &self,
1528 _req: crate::model::CreateMirroringDeploymentGroupRequest,
1529 _options: crate::RequestOptions,
1530 ) -> impl std::future::Future<
1531 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1532 > + Send {
1533 gaxi::unimplemented::unimplemented_stub()
1534 }
1535
1536 fn update_mirroring_deployment_group(
1538 &self,
1539 _req: crate::model::UpdateMirroringDeploymentGroupRequest,
1540 _options: crate::RequestOptions,
1541 ) -> impl std::future::Future<
1542 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1543 > + Send {
1544 gaxi::unimplemented::unimplemented_stub()
1545 }
1546
1547 fn delete_mirroring_deployment_group(
1549 &self,
1550 _req: crate::model::DeleteMirroringDeploymentGroupRequest,
1551 _options: crate::RequestOptions,
1552 ) -> impl std::future::Future<
1553 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1554 > + Send {
1555 gaxi::unimplemented::unimplemented_stub()
1556 }
1557
1558 fn list_mirroring_deployments(
1560 &self,
1561 _req: crate::model::ListMirroringDeploymentsRequest,
1562 _options: crate::RequestOptions,
1563 ) -> impl std::future::Future<
1564 Output = crate::Result<crate::Response<crate::model::ListMirroringDeploymentsResponse>>,
1565 > + Send {
1566 gaxi::unimplemented::unimplemented_stub()
1567 }
1568
1569 fn get_mirroring_deployment(
1571 &self,
1572 _req: crate::model::GetMirroringDeploymentRequest,
1573 _options: crate::RequestOptions,
1574 ) -> impl std::future::Future<
1575 Output = crate::Result<crate::Response<crate::model::MirroringDeployment>>,
1576 > + Send {
1577 gaxi::unimplemented::unimplemented_stub()
1578 }
1579
1580 fn create_mirroring_deployment(
1582 &self,
1583 _req: crate::model::CreateMirroringDeploymentRequest,
1584 _options: crate::RequestOptions,
1585 ) -> impl std::future::Future<
1586 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1587 > + Send {
1588 gaxi::unimplemented::unimplemented_stub()
1589 }
1590
1591 fn update_mirroring_deployment(
1593 &self,
1594 _req: crate::model::UpdateMirroringDeploymentRequest,
1595 _options: crate::RequestOptions,
1596 ) -> impl std::future::Future<
1597 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1598 > + Send {
1599 gaxi::unimplemented::unimplemented_stub()
1600 }
1601
1602 fn delete_mirroring_deployment(
1604 &self,
1605 _req: crate::model::DeleteMirroringDeploymentRequest,
1606 _options: crate::RequestOptions,
1607 ) -> impl std::future::Future<
1608 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1609 > + Send {
1610 gaxi::unimplemented::unimplemented_stub()
1611 }
1612
1613 fn list_locations(
1615 &self,
1616 _req: google_cloud_location::model::ListLocationsRequest,
1617 _options: crate::RequestOptions,
1618 ) -> impl std::future::Future<
1619 Output = crate::Result<
1620 crate::Response<google_cloud_location::model::ListLocationsResponse>,
1621 >,
1622 > + Send {
1623 gaxi::unimplemented::unimplemented_stub()
1624 }
1625
1626 fn get_location(
1628 &self,
1629 _req: google_cloud_location::model::GetLocationRequest,
1630 _options: crate::RequestOptions,
1631 ) -> impl std::future::Future<
1632 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
1633 > + Send {
1634 gaxi::unimplemented::unimplemented_stub()
1635 }
1636
1637 fn set_iam_policy(
1639 &self,
1640 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
1641 _options: crate::RequestOptions,
1642 ) -> impl std::future::Future<
1643 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
1644 > + Send {
1645 gaxi::unimplemented::unimplemented_stub()
1646 }
1647
1648 fn get_iam_policy(
1650 &self,
1651 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
1652 _options: crate::RequestOptions,
1653 ) -> impl std::future::Future<
1654 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
1655 > + Send {
1656 gaxi::unimplemented::unimplemented_stub()
1657 }
1658
1659 fn test_iam_permissions(
1661 &self,
1662 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
1663 _options: crate::RequestOptions,
1664 ) -> impl std::future::Future<
1665 Output = crate::Result<
1666 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
1667 >,
1668 > + Send {
1669 gaxi::unimplemented::unimplemented_stub()
1670 }
1671
1672 fn list_operations(
1674 &self,
1675 _req: google_cloud_longrunning::model::ListOperationsRequest,
1676 _options: crate::RequestOptions,
1677 ) -> impl std::future::Future<
1678 Output = crate::Result<
1679 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
1680 >,
1681 > + Send {
1682 gaxi::unimplemented::unimplemented_stub()
1683 }
1684
1685 fn get_operation(
1687 &self,
1688 _req: google_cloud_longrunning::model::GetOperationRequest,
1689 _options: crate::RequestOptions,
1690 ) -> impl std::future::Future<
1691 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1692 > + Send {
1693 gaxi::unimplemented::unimplemented_stub()
1694 }
1695
1696 fn delete_operation(
1698 &self,
1699 _req: google_cloud_longrunning::model::DeleteOperationRequest,
1700 _options: crate::RequestOptions,
1701 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
1702 gaxi::unimplemented::unimplemented_stub()
1703 }
1704
1705 fn cancel_operation(
1707 &self,
1708 _req: google_cloud_longrunning::model::CancelOperationRequest,
1709 _options: crate::RequestOptions,
1710 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
1711 gaxi::unimplemented::unimplemented_stub()
1712 }
1713
1714 fn get_polling_error_policy(
1719 &self,
1720 _options: &crate::RequestOptions,
1721 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
1722 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
1723 }
1724
1725 fn get_polling_backoff_policy(
1730 &self,
1731 _options: &crate::RequestOptions,
1732 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
1733 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
1734 }
1735
1736 #[doc(hidden)]
1737 fn get_poller_options(
1742 &self,
1743 _options: &crate::RequestOptions,
1744 ) -> google_cloud_lro::PollerOptions {
1745 google_cloud_lro::PollerOptions::default()
1746 }
1747}
1748
1749pub trait NetworkSecurity: std::fmt::Debug + Send + Sync {
1761 fn list_authorization_policies(
1763 &self,
1764 _req: crate::model::ListAuthorizationPoliciesRequest,
1765 _options: crate::RequestOptions,
1766 ) -> impl std::future::Future<
1767 Output = crate::Result<crate::Response<crate::model::ListAuthorizationPoliciesResponse>>,
1768 > + Send {
1769 gaxi::unimplemented::unimplemented_stub()
1770 }
1771
1772 fn get_authorization_policy(
1774 &self,
1775 _req: crate::model::GetAuthorizationPolicyRequest,
1776 _options: crate::RequestOptions,
1777 ) -> impl std::future::Future<
1778 Output = crate::Result<crate::Response<crate::model::AuthorizationPolicy>>,
1779 > + Send {
1780 gaxi::unimplemented::unimplemented_stub()
1781 }
1782
1783 fn create_authorization_policy(
1785 &self,
1786 _req: crate::model::CreateAuthorizationPolicyRequest,
1787 _options: crate::RequestOptions,
1788 ) -> impl std::future::Future<
1789 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1790 > + Send {
1791 gaxi::unimplemented::unimplemented_stub()
1792 }
1793
1794 fn update_authorization_policy(
1796 &self,
1797 _req: crate::model::UpdateAuthorizationPolicyRequest,
1798 _options: crate::RequestOptions,
1799 ) -> impl std::future::Future<
1800 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1801 > + Send {
1802 gaxi::unimplemented::unimplemented_stub()
1803 }
1804
1805 fn delete_authorization_policy(
1807 &self,
1808 _req: crate::model::DeleteAuthorizationPolicyRequest,
1809 _options: crate::RequestOptions,
1810 ) -> impl std::future::Future<
1811 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1812 > + Send {
1813 gaxi::unimplemented::unimplemented_stub()
1814 }
1815
1816 fn list_backend_authentication_configs(
1818 &self,
1819 _req: crate::model::ListBackendAuthenticationConfigsRequest,
1820 _options: crate::RequestOptions,
1821 ) -> impl std::future::Future<
1822 Output = crate::Result<
1823 crate::Response<crate::model::ListBackendAuthenticationConfigsResponse>,
1824 >,
1825 > + Send {
1826 gaxi::unimplemented::unimplemented_stub()
1827 }
1828
1829 fn get_backend_authentication_config(
1831 &self,
1832 _req: crate::model::GetBackendAuthenticationConfigRequest,
1833 _options: crate::RequestOptions,
1834 ) -> impl std::future::Future<
1835 Output = crate::Result<crate::Response<crate::model::BackendAuthenticationConfig>>,
1836 > + Send {
1837 gaxi::unimplemented::unimplemented_stub()
1838 }
1839
1840 fn create_backend_authentication_config(
1842 &self,
1843 _req: crate::model::CreateBackendAuthenticationConfigRequest,
1844 _options: crate::RequestOptions,
1845 ) -> impl std::future::Future<
1846 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1847 > + Send {
1848 gaxi::unimplemented::unimplemented_stub()
1849 }
1850
1851 fn update_backend_authentication_config(
1853 &self,
1854 _req: crate::model::UpdateBackendAuthenticationConfigRequest,
1855 _options: crate::RequestOptions,
1856 ) -> impl std::future::Future<
1857 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1858 > + Send {
1859 gaxi::unimplemented::unimplemented_stub()
1860 }
1861
1862 fn delete_backend_authentication_config(
1864 &self,
1865 _req: crate::model::DeleteBackendAuthenticationConfigRequest,
1866 _options: crate::RequestOptions,
1867 ) -> impl std::future::Future<
1868 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1869 > + Send {
1870 gaxi::unimplemented::unimplemented_stub()
1871 }
1872
1873 fn list_server_tls_policies(
1875 &self,
1876 _req: crate::model::ListServerTlsPoliciesRequest,
1877 _options: crate::RequestOptions,
1878 ) -> impl std::future::Future<
1879 Output = crate::Result<crate::Response<crate::model::ListServerTlsPoliciesResponse>>,
1880 > + Send {
1881 gaxi::unimplemented::unimplemented_stub()
1882 }
1883
1884 fn get_server_tls_policy(
1886 &self,
1887 _req: crate::model::GetServerTlsPolicyRequest,
1888 _options: crate::RequestOptions,
1889 ) -> impl std::future::Future<
1890 Output = crate::Result<crate::Response<crate::model::ServerTlsPolicy>>,
1891 > + Send {
1892 gaxi::unimplemented::unimplemented_stub()
1893 }
1894
1895 fn create_server_tls_policy(
1897 &self,
1898 _req: crate::model::CreateServerTlsPolicyRequest,
1899 _options: crate::RequestOptions,
1900 ) -> impl std::future::Future<
1901 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1902 > + Send {
1903 gaxi::unimplemented::unimplemented_stub()
1904 }
1905
1906 fn update_server_tls_policy(
1908 &self,
1909 _req: crate::model::UpdateServerTlsPolicyRequest,
1910 _options: crate::RequestOptions,
1911 ) -> impl std::future::Future<
1912 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1913 > + Send {
1914 gaxi::unimplemented::unimplemented_stub()
1915 }
1916
1917 fn delete_server_tls_policy(
1919 &self,
1920 _req: crate::model::DeleteServerTlsPolicyRequest,
1921 _options: crate::RequestOptions,
1922 ) -> impl std::future::Future<
1923 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1924 > + Send {
1925 gaxi::unimplemented::unimplemented_stub()
1926 }
1927
1928 fn list_client_tls_policies(
1930 &self,
1931 _req: crate::model::ListClientTlsPoliciesRequest,
1932 _options: crate::RequestOptions,
1933 ) -> impl std::future::Future<
1934 Output = crate::Result<crate::Response<crate::model::ListClientTlsPoliciesResponse>>,
1935 > + Send {
1936 gaxi::unimplemented::unimplemented_stub()
1937 }
1938
1939 fn get_client_tls_policy(
1941 &self,
1942 _req: crate::model::GetClientTlsPolicyRequest,
1943 _options: crate::RequestOptions,
1944 ) -> impl std::future::Future<
1945 Output = crate::Result<crate::Response<crate::model::ClientTlsPolicy>>,
1946 > + Send {
1947 gaxi::unimplemented::unimplemented_stub()
1948 }
1949
1950 fn create_client_tls_policy(
1952 &self,
1953 _req: crate::model::CreateClientTlsPolicyRequest,
1954 _options: crate::RequestOptions,
1955 ) -> impl std::future::Future<
1956 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1957 > + Send {
1958 gaxi::unimplemented::unimplemented_stub()
1959 }
1960
1961 fn update_client_tls_policy(
1963 &self,
1964 _req: crate::model::UpdateClientTlsPolicyRequest,
1965 _options: crate::RequestOptions,
1966 ) -> impl std::future::Future<
1967 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1968 > + Send {
1969 gaxi::unimplemented::unimplemented_stub()
1970 }
1971
1972 fn delete_client_tls_policy(
1974 &self,
1975 _req: crate::model::DeleteClientTlsPolicyRequest,
1976 _options: crate::RequestOptions,
1977 ) -> impl std::future::Future<
1978 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
1979 > + Send {
1980 gaxi::unimplemented::unimplemented_stub()
1981 }
1982
1983 fn list_gateway_security_policies(
1985 &self,
1986 _req: crate::model::ListGatewaySecurityPoliciesRequest,
1987 _options: crate::RequestOptions,
1988 ) -> impl std::future::Future<
1989 Output = crate::Result<crate::Response<crate::model::ListGatewaySecurityPoliciesResponse>>,
1990 > + Send {
1991 gaxi::unimplemented::unimplemented_stub()
1992 }
1993
1994 fn get_gateway_security_policy(
1996 &self,
1997 _req: crate::model::GetGatewaySecurityPolicyRequest,
1998 _options: crate::RequestOptions,
1999 ) -> impl std::future::Future<
2000 Output = crate::Result<crate::Response<crate::model::GatewaySecurityPolicy>>,
2001 > + Send {
2002 gaxi::unimplemented::unimplemented_stub()
2003 }
2004
2005 fn create_gateway_security_policy(
2007 &self,
2008 _req: crate::model::CreateGatewaySecurityPolicyRequest,
2009 _options: crate::RequestOptions,
2010 ) -> impl std::future::Future<
2011 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2012 > + Send {
2013 gaxi::unimplemented::unimplemented_stub()
2014 }
2015
2016 fn update_gateway_security_policy(
2018 &self,
2019 _req: crate::model::UpdateGatewaySecurityPolicyRequest,
2020 _options: crate::RequestOptions,
2021 ) -> impl std::future::Future<
2022 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2023 > + Send {
2024 gaxi::unimplemented::unimplemented_stub()
2025 }
2026
2027 fn delete_gateway_security_policy(
2029 &self,
2030 _req: crate::model::DeleteGatewaySecurityPolicyRequest,
2031 _options: crate::RequestOptions,
2032 ) -> impl std::future::Future<
2033 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2034 > + Send {
2035 gaxi::unimplemented::unimplemented_stub()
2036 }
2037
2038 fn list_gateway_security_policy_rules(
2040 &self,
2041 _req: crate::model::ListGatewaySecurityPolicyRulesRequest,
2042 _options: crate::RequestOptions,
2043 ) -> impl std::future::Future<
2044 Output = crate::Result<
2045 crate::Response<crate::model::ListGatewaySecurityPolicyRulesResponse>,
2046 >,
2047 > + Send {
2048 gaxi::unimplemented::unimplemented_stub()
2049 }
2050
2051 fn get_gateway_security_policy_rule(
2053 &self,
2054 _req: crate::model::GetGatewaySecurityPolicyRuleRequest,
2055 _options: crate::RequestOptions,
2056 ) -> impl std::future::Future<
2057 Output = crate::Result<crate::Response<crate::model::GatewaySecurityPolicyRule>>,
2058 > + Send {
2059 gaxi::unimplemented::unimplemented_stub()
2060 }
2061
2062 fn create_gateway_security_policy_rule(
2064 &self,
2065 _req: crate::model::CreateGatewaySecurityPolicyRuleRequest,
2066 _options: crate::RequestOptions,
2067 ) -> impl std::future::Future<
2068 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2069 > + Send {
2070 gaxi::unimplemented::unimplemented_stub()
2071 }
2072
2073 fn update_gateway_security_policy_rule(
2075 &self,
2076 _req: crate::model::UpdateGatewaySecurityPolicyRuleRequest,
2077 _options: crate::RequestOptions,
2078 ) -> impl std::future::Future<
2079 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2080 > + Send {
2081 gaxi::unimplemented::unimplemented_stub()
2082 }
2083
2084 fn delete_gateway_security_policy_rule(
2086 &self,
2087 _req: crate::model::DeleteGatewaySecurityPolicyRuleRequest,
2088 _options: crate::RequestOptions,
2089 ) -> impl std::future::Future<
2090 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2091 > + Send {
2092 gaxi::unimplemented::unimplemented_stub()
2093 }
2094
2095 fn list_url_lists(
2097 &self,
2098 _req: crate::model::ListUrlListsRequest,
2099 _options: crate::RequestOptions,
2100 ) -> impl std::future::Future<
2101 Output = crate::Result<crate::Response<crate::model::ListUrlListsResponse>>,
2102 > + Send {
2103 gaxi::unimplemented::unimplemented_stub()
2104 }
2105
2106 fn get_url_list(
2108 &self,
2109 _req: crate::model::GetUrlListRequest,
2110 _options: crate::RequestOptions,
2111 ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::UrlList>>> + Send
2112 {
2113 gaxi::unimplemented::unimplemented_stub()
2114 }
2115
2116 fn create_url_list(
2118 &self,
2119 _req: crate::model::CreateUrlListRequest,
2120 _options: crate::RequestOptions,
2121 ) -> impl std::future::Future<
2122 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2123 > + Send {
2124 gaxi::unimplemented::unimplemented_stub()
2125 }
2126
2127 fn update_url_list(
2129 &self,
2130 _req: crate::model::UpdateUrlListRequest,
2131 _options: crate::RequestOptions,
2132 ) -> impl std::future::Future<
2133 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2134 > + Send {
2135 gaxi::unimplemented::unimplemented_stub()
2136 }
2137
2138 fn delete_url_list(
2140 &self,
2141 _req: crate::model::DeleteUrlListRequest,
2142 _options: crate::RequestOptions,
2143 ) -> impl std::future::Future<
2144 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2145 > + Send {
2146 gaxi::unimplemented::unimplemented_stub()
2147 }
2148
2149 fn list_tls_inspection_policies(
2151 &self,
2152 _req: crate::model::ListTlsInspectionPoliciesRequest,
2153 _options: crate::RequestOptions,
2154 ) -> impl std::future::Future<
2155 Output = crate::Result<crate::Response<crate::model::ListTlsInspectionPoliciesResponse>>,
2156 > + Send {
2157 gaxi::unimplemented::unimplemented_stub()
2158 }
2159
2160 fn get_tls_inspection_policy(
2162 &self,
2163 _req: crate::model::GetTlsInspectionPolicyRequest,
2164 _options: crate::RequestOptions,
2165 ) -> impl std::future::Future<
2166 Output = crate::Result<crate::Response<crate::model::TlsInspectionPolicy>>,
2167 > + Send {
2168 gaxi::unimplemented::unimplemented_stub()
2169 }
2170
2171 fn create_tls_inspection_policy(
2173 &self,
2174 _req: crate::model::CreateTlsInspectionPolicyRequest,
2175 _options: crate::RequestOptions,
2176 ) -> impl std::future::Future<
2177 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2178 > + Send {
2179 gaxi::unimplemented::unimplemented_stub()
2180 }
2181
2182 fn update_tls_inspection_policy(
2184 &self,
2185 _req: crate::model::UpdateTlsInspectionPolicyRequest,
2186 _options: crate::RequestOptions,
2187 ) -> impl std::future::Future<
2188 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2189 > + Send {
2190 gaxi::unimplemented::unimplemented_stub()
2191 }
2192
2193 fn delete_tls_inspection_policy(
2195 &self,
2196 _req: crate::model::DeleteTlsInspectionPolicyRequest,
2197 _options: crate::RequestOptions,
2198 ) -> impl std::future::Future<
2199 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2200 > + Send {
2201 gaxi::unimplemented::unimplemented_stub()
2202 }
2203
2204 fn list_authz_policies(
2206 &self,
2207 _req: crate::model::ListAuthzPoliciesRequest,
2208 _options: crate::RequestOptions,
2209 ) -> impl std::future::Future<
2210 Output = crate::Result<crate::Response<crate::model::ListAuthzPoliciesResponse>>,
2211 > + Send {
2212 gaxi::unimplemented::unimplemented_stub()
2213 }
2214
2215 fn get_authz_policy(
2217 &self,
2218 _req: crate::model::GetAuthzPolicyRequest,
2219 _options: crate::RequestOptions,
2220 ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::AuthzPolicy>>>
2221 + Send {
2222 gaxi::unimplemented::unimplemented_stub()
2223 }
2224
2225 fn create_authz_policy(
2227 &self,
2228 _req: crate::model::CreateAuthzPolicyRequest,
2229 _options: crate::RequestOptions,
2230 ) -> impl std::future::Future<
2231 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2232 > + Send {
2233 gaxi::unimplemented::unimplemented_stub()
2234 }
2235
2236 fn update_authz_policy(
2238 &self,
2239 _req: crate::model::UpdateAuthzPolicyRequest,
2240 _options: crate::RequestOptions,
2241 ) -> impl std::future::Future<
2242 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2243 > + Send {
2244 gaxi::unimplemented::unimplemented_stub()
2245 }
2246
2247 fn delete_authz_policy(
2249 &self,
2250 _req: crate::model::DeleteAuthzPolicyRequest,
2251 _options: crate::RequestOptions,
2252 ) -> impl std::future::Future<
2253 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2254 > + Send {
2255 gaxi::unimplemented::unimplemented_stub()
2256 }
2257
2258 fn list_locations(
2260 &self,
2261 _req: google_cloud_location::model::ListLocationsRequest,
2262 _options: crate::RequestOptions,
2263 ) -> impl std::future::Future<
2264 Output = crate::Result<
2265 crate::Response<google_cloud_location::model::ListLocationsResponse>,
2266 >,
2267 > + Send {
2268 gaxi::unimplemented::unimplemented_stub()
2269 }
2270
2271 fn get_location(
2273 &self,
2274 _req: google_cloud_location::model::GetLocationRequest,
2275 _options: crate::RequestOptions,
2276 ) -> impl std::future::Future<
2277 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
2278 > + Send {
2279 gaxi::unimplemented::unimplemented_stub()
2280 }
2281
2282 fn set_iam_policy(
2284 &self,
2285 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
2286 _options: crate::RequestOptions,
2287 ) -> impl std::future::Future<
2288 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2289 > + Send {
2290 gaxi::unimplemented::unimplemented_stub()
2291 }
2292
2293 fn get_iam_policy(
2295 &self,
2296 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
2297 _options: crate::RequestOptions,
2298 ) -> impl std::future::Future<
2299 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2300 > + Send {
2301 gaxi::unimplemented::unimplemented_stub()
2302 }
2303
2304 fn test_iam_permissions(
2306 &self,
2307 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
2308 _options: crate::RequestOptions,
2309 ) -> impl std::future::Future<
2310 Output = crate::Result<
2311 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
2312 >,
2313 > + Send {
2314 gaxi::unimplemented::unimplemented_stub()
2315 }
2316
2317 fn list_operations(
2319 &self,
2320 _req: google_cloud_longrunning::model::ListOperationsRequest,
2321 _options: crate::RequestOptions,
2322 ) -> impl std::future::Future<
2323 Output = crate::Result<
2324 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
2325 >,
2326 > + Send {
2327 gaxi::unimplemented::unimplemented_stub()
2328 }
2329
2330 fn get_operation(
2332 &self,
2333 _req: google_cloud_longrunning::model::GetOperationRequest,
2334 _options: crate::RequestOptions,
2335 ) -> impl std::future::Future<
2336 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2337 > + Send {
2338 gaxi::unimplemented::unimplemented_stub()
2339 }
2340
2341 fn delete_operation(
2343 &self,
2344 _req: google_cloud_longrunning::model::DeleteOperationRequest,
2345 _options: crate::RequestOptions,
2346 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2347 gaxi::unimplemented::unimplemented_stub()
2348 }
2349
2350 fn cancel_operation(
2352 &self,
2353 _req: google_cloud_longrunning::model::CancelOperationRequest,
2354 _options: crate::RequestOptions,
2355 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2356 gaxi::unimplemented::unimplemented_stub()
2357 }
2358
2359 fn get_polling_error_policy(
2364 &self,
2365 _options: &crate::RequestOptions,
2366 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
2367 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
2368 }
2369
2370 fn get_polling_backoff_policy(
2375 &self,
2376 _options: &crate::RequestOptions,
2377 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
2378 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
2379 }
2380
2381 #[doc(hidden)]
2382 fn get_poller_options(
2387 &self,
2388 _options: &crate::RequestOptions,
2389 ) -> google_cloud_lro::PollerOptions {
2390 google_cloud_lro::PollerOptions::default()
2391 }
2392}
2393
2394pub trait SecurityProfileGroupService: std::fmt::Debug + Send + Sync {
2406 fn list_security_profile_groups(
2408 &self,
2409 _req: crate::model::ListSecurityProfileGroupsRequest,
2410 _options: crate::RequestOptions,
2411 ) -> impl std::future::Future<
2412 Output = crate::Result<crate::Response<crate::model::ListSecurityProfileGroupsResponse>>,
2413 > + Send {
2414 gaxi::unimplemented::unimplemented_stub()
2415 }
2416
2417 fn get_security_profile_group(
2419 &self,
2420 _req: crate::model::GetSecurityProfileGroupRequest,
2421 _options: crate::RequestOptions,
2422 ) -> impl std::future::Future<
2423 Output = crate::Result<crate::Response<crate::model::SecurityProfileGroup>>,
2424 > + Send {
2425 gaxi::unimplemented::unimplemented_stub()
2426 }
2427
2428 fn create_security_profile_group(
2430 &self,
2431 _req: crate::model::CreateSecurityProfileGroupRequest,
2432 _options: crate::RequestOptions,
2433 ) -> impl std::future::Future<
2434 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2435 > + Send {
2436 gaxi::unimplemented::unimplemented_stub()
2437 }
2438
2439 fn update_security_profile_group(
2441 &self,
2442 _req: crate::model::UpdateSecurityProfileGroupRequest,
2443 _options: crate::RequestOptions,
2444 ) -> impl std::future::Future<
2445 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2446 > + Send {
2447 gaxi::unimplemented::unimplemented_stub()
2448 }
2449
2450 fn delete_security_profile_group(
2452 &self,
2453 _req: crate::model::DeleteSecurityProfileGroupRequest,
2454 _options: crate::RequestOptions,
2455 ) -> impl std::future::Future<
2456 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2457 > + Send {
2458 gaxi::unimplemented::unimplemented_stub()
2459 }
2460
2461 fn list_security_profiles(
2463 &self,
2464 _req: crate::model::ListSecurityProfilesRequest,
2465 _options: crate::RequestOptions,
2466 ) -> impl std::future::Future<
2467 Output = crate::Result<crate::Response<crate::model::ListSecurityProfilesResponse>>,
2468 > + Send {
2469 gaxi::unimplemented::unimplemented_stub()
2470 }
2471
2472 fn get_security_profile(
2474 &self,
2475 _req: crate::model::GetSecurityProfileRequest,
2476 _options: crate::RequestOptions,
2477 ) -> impl std::future::Future<
2478 Output = crate::Result<crate::Response<crate::model::SecurityProfile>>,
2479 > + Send {
2480 gaxi::unimplemented::unimplemented_stub()
2481 }
2482
2483 fn create_security_profile(
2485 &self,
2486 _req: crate::model::CreateSecurityProfileRequest,
2487 _options: crate::RequestOptions,
2488 ) -> impl std::future::Future<
2489 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2490 > + Send {
2491 gaxi::unimplemented::unimplemented_stub()
2492 }
2493
2494 fn update_security_profile(
2496 &self,
2497 _req: crate::model::UpdateSecurityProfileRequest,
2498 _options: crate::RequestOptions,
2499 ) -> impl std::future::Future<
2500 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2501 > + Send {
2502 gaxi::unimplemented::unimplemented_stub()
2503 }
2504
2505 fn delete_security_profile(
2507 &self,
2508 _req: crate::model::DeleteSecurityProfileRequest,
2509 _options: crate::RequestOptions,
2510 ) -> impl std::future::Future<
2511 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2512 > + Send {
2513 gaxi::unimplemented::unimplemented_stub()
2514 }
2515
2516 fn list_locations(
2518 &self,
2519 _req: google_cloud_location::model::ListLocationsRequest,
2520 _options: crate::RequestOptions,
2521 ) -> impl std::future::Future<
2522 Output = crate::Result<
2523 crate::Response<google_cloud_location::model::ListLocationsResponse>,
2524 >,
2525 > + Send {
2526 gaxi::unimplemented::unimplemented_stub()
2527 }
2528
2529 fn get_location(
2531 &self,
2532 _req: google_cloud_location::model::GetLocationRequest,
2533 _options: crate::RequestOptions,
2534 ) -> impl std::future::Future<
2535 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
2536 > + Send {
2537 gaxi::unimplemented::unimplemented_stub()
2538 }
2539
2540 fn set_iam_policy(
2542 &self,
2543 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
2544 _options: crate::RequestOptions,
2545 ) -> impl std::future::Future<
2546 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2547 > + Send {
2548 gaxi::unimplemented::unimplemented_stub()
2549 }
2550
2551 fn get_iam_policy(
2553 &self,
2554 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
2555 _options: crate::RequestOptions,
2556 ) -> impl std::future::Future<
2557 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2558 > + Send {
2559 gaxi::unimplemented::unimplemented_stub()
2560 }
2561
2562 fn test_iam_permissions(
2564 &self,
2565 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
2566 _options: crate::RequestOptions,
2567 ) -> impl std::future::Future<
2568 Output = crate::Result<
2569 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
2570 >,
2571 > + Send {
2572 gaxi::unimplemented::unimplemented_stub()
2573 }
2574
2575 fn list_operations(
2577 &self,
2578 _req: google_cloud_longrunning::model::ListOperationsRequest,
2579 _options: crate::RequestOptions,
2580 ) -> impl std::future::Future<
2581 Output = crate::Result<
2582 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
2583 >,
2584 > + Send {
2585 gaxi::unimplemented::unimplemented_stub()
2586 }
2587
2588 fn get_operation(
2590 &self,
2591 _req: google_cloud_longrunning::model::GetOperationRequest,
2592 _options: crate::RequestOptions,
2593 ) -> impl std::future::Future<
2594 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2595 > + Send {
2596 gaxi::unimplemented::unimplemented_stub()
2597 }
2598
2599 fn delete_operation(
2601 &self,
2602 _req: google_cloud_longrunning::model::DeleteOperationRequest,
2603 _options: crate::RequestOptions,
2604 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2605 gaxi::unimplemented::unimplemented_stub()
2606 }
2607
2608 fn cancel_operation(
2610 &self,
2611 _req: google_cloud_longrunning::model::CancelOperationRequest,
2612 _options: crate::RequestOptions,
2613 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2614 gaxi::unimplemented::unimplemented_stub()
2615 }
2616
2617 fn get_polling_error_policy(
2622 &self,
2623 _options: &crate::RequestOptions,
2624 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
2625 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
2626 }
2627
2628 fn get_polling_backoff_policy(
2633 &self,
2634 _options: &crate::RequestOptions,
2635 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
2636 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
2637 }
2638
2639 #[doc(hidden)]
2640 fn get_poller_options(
2645 &self,
2646 _options: &crate::RequestOptions,
2647 ) -> google_cloud_lro::PollerOptions {
2648 google_cloud_lro::PollerOptions::default()
2649 }
2650}
2651
2652pub trait OrganizationSecurityProfileGroupService: std::fmt::Debug + Send + Sync {
2664 fn list_security_profile_groups(
2666 &self,
2667 _req: crate::model::ListSecurityProfileGroupsRequest,
2668 _options: crate::RequestOptions,
2669 ) -> impl std::future::Future<
2670 Output = crate::Result<crate::Response<crate::model::ListSecurityProfileGroupsResponse>>,
2671 > + Send {
2672 gaxi::unimplemented::unimplemented_stub()
2673 }
2674
2675 fn get_security_profile_group(
2677 &self,
2678 _req: crate::model::GetSecurityProfileGroupRequest,
2679 _options: crate::RequestOptions,
2680 ) -> impl std::future::Future<
2681 Output = crate::Result<crate::Response<crate::model::SecurityProfileGroup>>,
2682 > + Send {
2683 gaxi::unimplemented::unimplemented_stub()
2684 }
2685
2686 fn create_security_profile_group(
2688 &self,
2689 _req: crate::model::CreateSecurityProfileGroupRequest,
2690 _options: crate::RequestOptions,
2691 ) -> impl std::future::Future<
2692 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2693 > + Send {
2694 gaxi::unimplemented::unimplemented_stub()
2695 }
2696
2697 fn update_security_profile_group(
2699 &self,
2700 _req: crate::model::UpdateSecurityProfileGroupRequest,
2701 _options: crate::RequestOptions,
2702 ) -> impl std::future::Future<
2703 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2704 > + Send {
2705 gaxi::unimplemented::unimplemented_stub()
2706 }
2707
2708 fn delete_security_profile_group(
2710 &self,
2711 _req: crate::model::DeleteSecurityProfileGroupRequest,
2712 _options: crate::RequestOptions,
2713 ) -> impl std::future::Future<
2714 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2715 > + Send {
2716 gaxi::unimplemented::unimplemented_stub()
2717 }
2718
2719 fn list_security_profiles(
2721 &self,
2722 _req: crate::model::ListSecurityProfilesRequest,
2723 _options: crate::RequestOptions,
2724 ) -> impl std::future::Future<
2725 Output = crate::Result<crate::Response<crate::model::ListSecurityProfilesResponse>>,
2726 > + Send {
2727 gaxi::unimplemented::unimplemented_stub()
2728 }
2729
2730 fn get_security_profile(
2732 &self,
2733 _req: crate::model::GetSecurityProfileRequest,
2734 _options: crate::RequestOptions,
2735 ) -> impl std::future::Future<
2736 Output = crate::Result<crate::Response<crate::model::SecurityProfile>>,
2737 > + Send {
2738 gaxi::unimplemented::unimplemented_stub()
2739 }
2740
2741 fn create_security_profile(
2743 &self,
2744 _req: crate::model::CreateSecurityProfileRequest,
2745 _options: crate::RequestOptions,
2746 ) -> impl std::future::Future<
2747 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2748 > + Send {
2749 gaxi::unimplemented::unimplemented_stub()
2750 }
2751
2752 fn update_security_profile(
2754 &self,
2755 _req: crate::model::UpdateSecurityProfileRequest,
2756 _options: crate::RequestOptions,
2757 ) -> impl std::future::Future<
2758 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2759 > + Send {
2760 gaxi::unimplemented::unimplemented_stub()
2761 }
2762
2763 fn delete_security_profile(
2765 &self,
2766 _req: crate::model::DeleteSecurityProfileRequest,
2767 _options: crate::RequestOptions,
2768 ) -> impl std::future::Future<
2769 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2770 > + Send {
2771 gaxi::unimplemented::unimplemented_stub()
2772 }
2773
2774 fn list_locations(
2776 &self,
2777 _req: google_cloud_location::model::ListLocationsRequest,
2778 _options: crate::RequestOptions,
2779 ) -> impl std::future::Future<
2780 Output = crate::Result<
2781 crate::Response<google_cloud_location::model::ListLocationsResponse>,
2782 >,
2783 > + Send {
2784 gaxi::unimplemented::unimplemented_stub()
2785 }
2786
2787 fn get_location(
2789 &self,
2790 _req: google_cloud_location::model::GetLocationRequest,
2791 _options: crate::RequestOptions,
2792 ) -> impl std::future::Future<
2793 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
2794 > + Send {
2795 gaxi::unimplemented::unimplemented_stub()
2796 }
2797
2798 fn set_iam_policy(
2800 &self,
2801 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
2802 _options: crate::RequestOptions,
2803 ) -> impl std::future::Future<
2804 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2805 > + Send {
2806 gaxi::unimplemented::unimplemented_stub()
2807 }
2808
2809 fn get_iam_policy(
2811 &self,
2812 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
2813 _options: crate::RequestOptions,
2814 ) -> impl std::future::Future<
2815 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
2816 > + Send {
2817 gaxi::unimplemented::unimplemented_stub()
2818 }
2819
2820 fn test_iam_permissions(
2822 &self,
2823 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
2824 _options: crate::RequestOptions,
2825 ) -> impl std::future::Future<
2826 Output = crate::Result<
2827 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
2828 >,
2829 > + Send {
2830 gaxi::unimplemented::unimplemented_stub()
2831 }
2832
2833 fn list_operations(
2835 &self,
2836 _req: google_cloud_longrunning::model::ListOperationsRequest,
2837 _options: crate::RequestOptions,
2838 ) -> impl std::future::Future<
2839 Output = crate::Result<
2840 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
2841 >,
2842 > + Send {
2843 gaxi::unimplemented::unimplemented_stub()
2844 }
2845
2846 fn get_operation(
2848 &self,
2849 _req: google_cloud_longrunning::model::GetOperationRequest,
2850 _options: crate::RequestOptions,
2851 ) -> impl std::future::Future<
2852 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2853 > + Send {
2854 gaxi::unimplemented::unimplemented_stub()
2855 }
2856
2857 fn delete_operation(
2859 &self,
2860 _req: google_cloud_longrunning::model::DeleteOperationRequest,
2861 _options: crate::RequestOptions,
2862 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2863 gaxi::unimplemented::unimplemented_stub()
2864 }
2865
2866 fn cancel_operation(
2868 &self,
2869 _req: google_cloud_longrunning::model::CancelOperationRequest,
2870 _options: crate::RequestOptions,
2871 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
2872 gaxi::unimplemented::unimplemented_stub()
2873 }
2874
2875 fn get_polling_error_policy(
2880 &self,
2881 _options: &crate::RequestOptions,
2882 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
2883 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
2884 }
2885
2886 fn get_polling_backoff_policy(
2891 &self,
2892 _options: &crate::RequestOptions,
2893 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
2894 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
2895 }
2896
2897 #[doc(hidden)]
2898 fn get_poller_options(
2903 &self,
2904 _options: &crate::RequestOptions,
2905 ) -> google_cloud_lro::PollerOptions {
2906 google_cloud_lro::PollerOptions::default()
2907 }
2908}
2909
2910pub trait SSERealmService: std::fmt::Debug + Send + Sync {
2922 fn list_sac_realms(
2924 &self,
2925 _req: crate::model::ListSACRealmsRequest,
2926 _options: crate::RequestOptions,
2927 ) -> impl std::future::Future<
2928 Output = crate::Result<crate::Response<crate::model::ListSACRealmsResponse>>,
2929 > + Send {
2930 gaxi::unimplemented::unimplemented_stub()
2931 }
2932
2933 fn get_sac_realm(
2935 &self,
2936 _req: crate::model::GetSACRealmRequest,
2937 _options: crate::RequestOptions,
2938 ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::SACRealm>>> + Send
2939 {
2940 gaxi::unimplemented::unimplemented_stub()
2941 }
2942
2943 fn create_sac_realm(
2945 &self,
2946 _req: crate::model::CreateSACRealmRequest,
2947 _options: crate::RequestOptions,
2948 ) -> impl std::future::Future<
2949 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2950 > + Send {
2951 gaxi::unimplemented::unimplemented_stub()
2952 }
2953
2954 fn delete_sac_realm(
2956 &self,
2957 _req: crate::model::DeleteSACRealmRequest,
2958 _options: crate::RequestOptions,
2959 ) -> impl std::future::Future<
2960 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2961 > + Send {
2962 gaxi::unimplemented::unimplemented_stub()
2963 }
2964
2965 fn list_sac_attachments(
2967 &self,
2968 _req: crate::model::ListSACAttachmentsRequest,
2969 _options: crate::RequestOptions,
2970 ) -> impl std::future::Future<
2971 Output = crate::Result<crate::Response<crate::model::ListSACAttachmentsResponse>>,
2972 > + Send {
2973 gaxi::unimplemented::unimplemented_stub()
2974 }
2975
2976 fn get_sac_attachment(
2978 &self,
2979 _req: crate::model::GetSACAttachmentRequest,
2980 _options: crate::RequestOptions,
2981 ) -> impl std::future::Future<
2982 Output = crate::Result<crate::Response<crate::model::SACAttachment>>,
2983 > + Send {
2984 gaxi::unimplemented::unimplemented_stub()
2985 }
2986
2987 fn create_sac_attachment(
2989 &self,
2990 _req: crate::model::CreateSACAttachmentRequest,
2991 _options: crate::RequestOptions,
2992 ) -> impl std::future::Future<
2993 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
2994 > + Send {
2995 gaxi::unimplemented::unimplemented_stub()
2996 }
2997
2998 fn delete_sac_attachment(
3000 &self,
3001 _req: crate::model::DeleteSACAttachmentRequest,
3002 _options: crate::RequestOptions,
3003 ) -> impl std::future::Future<
3004 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
3005 > + Send {
3006 gaxi::unimplemented::unimplemented_stub()
3007 }
3008
3009 fn list_locations(
3011 &self,
3012 _req: google_cloud_location::model::ListLocationsRequest,
3013 _options: crate::RequestOptions,
3014 ) -> impl std::future::Future<
3015 Output = crate::Result<
3016 crate::Response<google_cloud_location::model::ListLocationsResponse>,
3017 >,
3018 > + Send {
3019 gaxi::unimplemented::unimplemented_stub()
3020 }
3021
3022 fn get_location(
3024 &self,
3025 _req: google_cloud_location::model::GetLocationRequest,
3026 _options: crate::RequestOptions,
3027 ) -> impl std::future::Future<
3028 Output = crate::Result<crate::Response<google_cloud_location::model::Location>>,
3029 > + Send {
3030 gaxi::unimplemented::unimplemented_stub()
3031 }
3032
3033 fn set_iam_policy(
3035 &self,
3036 _req: google_cloud_iam_v1::model::SetIamPolicyRequest,
3037 _options: crate::RequestOptions,
3038 ) -> impl std::future::Future<
3039 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
3040 > + Send {
3041 gaxi::unimplemented::unimplemented_stub()
3042 }
3043
3044 fn get_iam_policy(
3046 &self,
3047 _req: google_cloud_iam_v1::model::GetIamPolicyRequest,
3048 _options: crate::RequestOptions,
3049 ) -> impl std::future::Future<
3050 Output = crate::Result<crate::Response<google_cloud_iam_v1::model::Policy>>,
3051 > + Send {
3052 gaxi::unimplemented::unimplemented_stub()
3053 }
3054
3055 fn test_iam_permissions(
3057 &self,
3058 _req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
3059 _options: crate::RequestOptions,
3060 ) -> impl std::future::Future<
3061 Output = crate::Result<
3062 crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>,
3063 >,
3064 > + Send {
3065 gaxi::unimplemented::unimplemented_stub()
3066 }
3067
3068 fn list_operations(
3070 &self,
3071 _req: google_cloud_longrunning::model::ListOperationsRequest,
3072 _options: crate::RequestOptions,
3073 ) -> impl std::future::Future<
3074 Output = crate::Result<
3075 crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
3076 >,
3077 > + Send {
3078 gaxi::unimplemented::unimplemented_stub()
3079 }
3080
3081 fn get_operation(
3083 &self,
3084 _req: google_cloud_longrunning::model::GetOperationRequest,
3085 _options: crate::RequestOptions,
3086 ) -> impl std::future::Future<
3087 Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
3088 > + Send {
3089 gaxi::unimplemented::unimplemented_stub()
3090 }
3091
3092 fn delete_operation(
3094 &self,
3095 _req: google_cloud_longrunning::model::DeleteOperationRequest,
3096 _options: crate::RequestOptions,
3097 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
3098 gaxi::unimplemented::unimplemented_stub()
3099 }
3100
3101 fn cancel_operation(
3103 &self,
3104 _req: google_cloud_longrunning::model::CancelOperationRequest,
3105 _options: crate::RequestOptions,
3106 ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
3107 gaxi::unimplemented::unimplemented_stub()
3108 }
3109
3110 fn get_polling_error_policy(
3115 &self,
3116 _options: &crate::RequestOptions,
3117 ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
3118 std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
3119 }
3120
3121 fn get_polling_backoff_policy(
3126 &self,
3127 _options: &crate::RequestOptions,
3128 ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
3129 std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
3130 }
3131
3132 #[doc(hidden)]
3133 fn get_poller_options(
3138 &self,
3139 _options: &crate::RequestOptions,
3140 ) -> google_cloud_lro::PollerOptions {
3141 google_cloud_lro::PollerOptions::default()
3142 }
3143}