Skip to main content

google_cloud_appengine_v1/
stub.rs

1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Code generated by sidekick. DO NOT EDIT.
16
17//! Traits to mock the clients in this library.
18//!
19//! Application developers may need to mock the clients in this library to test
20//! how their application works with different (and sometimes hard to trigger)
21//! client and service behavior. Such test can define mocks implementing the
22//! trait(s) defined in this module, initialize the client with an instance of
23//! this mock in their tests, and verify their application responds as expected.
24
25#![allow(rustdoc::broken_intra_doc_links)]
26
27pub(crate) mod dynamic;
28
29/// Defines the trait used to implement [super::client::Applications].
30///
31/// Application developers may need to implement this trait to mock
32/// `client::Applications`.  In other use-cases, application developers only
33/// use `client::Applications` and need not be concerned with this trait or
34/// its implementations.
35///
36/// Services gain new RPCs routinely. Consequently, this trait gains new methods
37/// too. To avoid breaking applications the trait provides a default
38/// implementation of each method. Most of these implementations just return an
39/// error.
40pub trait Applications: std::fmt::Debug + Send + Sync {
41    /// Implements [super::client::Applications::get_application].
42    fn get_application(
43        &self,
44        _req: crate::model::GetApplicationRequest,
45        _options: crate::RequestOptions,
46    ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::Application>>>
47    + Send {
48        gaxi::unimplemented::unimplemented_stub()
49    }
50
51    /// Implements [super::client::Applications::create_application].
52    fn create_application(
53        &self,
54        _req: crate::model::CreateApplicationRequest,
55        _options: crate::RequestOptions,
56    ) -> impl std::future::Future<
57        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
58    > + Send {
59        gaxi::unimplemented::unimplemented_stub()
60    }
61
62    /// Implements [super::client::Applications::update_application].
63    fn update_application(
64        &self,
65        _req: crate::model::UpdateApplicationRequest,
66        _options: crate::RequestOptions,
67    ) -> impl std::future::Future<
68        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
69    > + Send {
70        gaxi::unimplemented::unimplemented_stub()
71    }
72
73    /// Implements [super::client::Applications::repair_application].
74    fn repair_application(
75        &self,
76        _req: crate::model::RepairApplicationRequest,
77        _options: crate::RequestOptions,
78    ) -> impl std::future::Future<
79        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
80    > + Send {
81        gaxi::unimplemented::unimplemented_stub()
82    }
83
84    /// Implements [super::client::Applications::list_operations].
85    fn list_operations(
86        &self,
87        _req: google_cloud_longrunning::model::ListOperationsRequest,
88        _options: crate::RequestOptions,
89    ) -> impl std::future::Future<
90        Output = crate::Result<
91            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
92        >,
93    > + Send {
94        gaxi::unimplemented::unimplemented_stub()
95    }
96
97    /// Implements [super::client::Applications::get_operation].
98    fn get_operation(
99        &self,
100        _req: google_cloud_longrunning::model::GetOperationRequest,
101        _options: crate::RequestOptions,
102    ) -> impl std::future::Future<
103        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
104    > + Send {
105        gaxi::unimplemented::unimplemented_stub()
106    }
107
108    /// Returns the polling error policy.
109    ///
110    /// When mocking, this method is typically irrelevant. Do not try to verify
111    /// it is called by your mocks.
112    fn get_polling_error_policy(
113        &self,
114        _options: &crate::RequestOptions,
115    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
116        std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
117    }
118
119    /// Returns the polling backoff policy.
120    ///
121    /// When mocking, this method is typically irrelevant. Do not try to verify
122    /// it is called by your mocks.
123    fn get_polling_backoff_policy(
124        &self,
125        _options: &crate::RequestOptions,
126    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
127        std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
128    }
129}
130
131/// Defines the trait used to implement [super::client::Services].
132///
133/// Application developers may need to implement this trait to mock
134/// `client::Services`.  In other use-cases, application developers only
135/// use `client::Services` and need not be concerned with this trait or
136/// its implementations.
137///
138/// Services gain new RPCs routinely. Consequently, this trait gains new methods
139/// too. To avoid breaking applications the trait provides a default
140/// implementation of each method. Most of these implementations just return an
141/// error.
142pub trait Services: std::fmt::Debug + Send + Sync {
143    /// Implements [super::client::Services::list_services].
144    fn list_services(
145        &self,
146        _req: crate::model::ListServicesRequest,
147        _options: crate::RequestOptions,
148    ) -> impl std::future::Future<
149        Output = crate::Result<crate::Response<crate::model::ListServicesResponse>>,
150    > + Send {
151        gaxi::unimplemented::unimplemented_stub()
152    }
153
154    /// Implements [super::client::Services::get_service].
155    fn get_service(
156        &self,
157        _req: crate::model::GetServiceRequest,
158        _options: crate::RequestOptions,
159    ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::Service>>> + Send
160    {
161        gaxi::unimplemented::unimplemented_stub()
162    }
163
164    /// Implements [super::client::Services::update_service].
165    fn update_service(
166        &self,
167        _req: crate::model::UpdateServiceRequest,
168        _options: crate::RequestOptions,
169    ) -> impl std::future::Future<
170        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
171    > + Send {
172        gaxi::unimplemented::unimplemented_stub()
173    }
174
175    /// Implements [super::client::Services::delete_service].
176    fn delete_service(
177        &self,
178        _req: crate::model::DeleteServiceRequest,
179        _options: crate::RequestOptions,
180    ) -> impl std::future::Future<
181        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
182    > + Send {
183        gaxi::unimplemented::unimplemented_stub()
184    }
185
186    /// Implements [super::client::Services::list_operations].
187    fn list_operations(
188        &self,
189        _req: google_cloud_longrunning::model::ListOperationsRequest,
190        _options: crate::RequestOptions,
191    ) -> impl std::future::Future<
192        Output = crate::Result<
193            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
194        >,
195    > + Send {
196        gaxi::unimplemented::unimplemented_stub()
197    }
198
199    /// Implements [super::client::Services::get_operation].
200    fn get_operation(
201        &self,
202        _req: google_cloud_longrunning::model::GetOperationRequest,
203        _options: crate::RequestOptions,
204    ) -> impl std::future::Future<
205        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
206    > + Send {
207        gaxi::unimplemented::unimplemented_stub()
208    }
209
210    /// Returns the polling error policy.
211    ///
212    /// When mocking, this method is typically irrelevant. Do not try to verify
213    /// it is called by your mocks.
214    fn get_polling_error_policy(
215        &self,
216        _options: &crate::RequestOptions,
217    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
218        std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
219    }
220
221    /// Returns the polling backoff policy.
222    ///
223    /// When mocking, this method is typically irrelevant. Do not try to verify
224    /// it is called by your mocks.
225    fn get_polling_backoff_policy(
226        &self,
227        _options: &crate::RequestOptions,
228    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
229        std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
230    }
231}
232
233/// Defines the trait used to implement [super::client::Versions].
234///
235/// Application developers may need to implement this trait to mock
236/// `client::Versions`.  In other use-cases, application developers only
237/// use `client::Versions` and need not be concerned with this trait or
238/// its implementations.
239///
240/// Services gain new RPCs routinely. Consequently, this trait gains new methods
241/// too. To avoid breaking applications the trait provides a default
242/// implementation of each method. Most of these implementations just return an
243/// error.
244pub trait Versions: std::fmt::Debug + Send + Sync {
245    /// Implements [super::client::Versions::list_versions].
246    fn list_versions(
247        &self,
248        _req: crate::model::ListVersionsRequest,
249        _options: crate::RequestOptions,
250    ) -> impl std::future::Future<
251        Output = crate::Result<crate::Response<crate::model::ListVersionsResponse>>,
252    > + Send {
253        gaxi::unimplemented::unimplemented_stub()
254    }
255
256    /// Implements [super::client::Versions::get_version].
257    fn get_version(
258        &self,
259        _req: crate::model::GetVersionRequest,
260        _options: crate::RequestOptions,
261    ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::Version>>> + Send
262    {
263        gaxi::unimplemented::unimplemented_stub()
264    }
265
266    /// Implements [super::client::Versions::create_version].
267    fn create_version(
268        &self,
269        _req: crate::model::CreateVersionRequest,
270        _options: crate::RequestOptions,
271    ) -> impl std::future::Future<
272        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
273    > + Send {
274        gaxi::unimplemented::unimplemented_stub()
275    }
276
277    /// Implements [super::client::Versions::update_version].
278    fn update_version(
279        &self,
280        _req: crate::model::UpdateVersionRequest,
281        _options: crate::RequestOptions,
282    ) -> impl std::future::Future<
283        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
284    > + Send {
285        gaxi::unimplemented::unimplemented_stub()
286    }
287
288    /// Implements [super::client::Versions::delete_version].
289    fn delete_version(
290        &self,
291        _req: crate::model::DeleteVersionRequest,
292        _options: crate::RequestOptions,
293    ) -> impl std::future::Future<
294        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
295    > + Send {
296        gaxi::unimplemented::unimplemented_stub()
297    }
298
299    /// Implements [super::client::Versions::list_operations].
300    fn list_operations(
301        &self,
302        _req: google_cloud_longrunning::model::ListOperationsRequest,
303        _options: crate::RequestOptions,
304    ) -> impl std::future::Future<
305        Output = crate::Result<
306            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
307        >,
308    > + Send {
309        gaxi::unimplemented::unimplemented_stub()
310    }
311
312    /// Implements [super::client::Versions::get_operation].
313    fn get_operation(
314        &self,
315        _req: google_cloud_longrunning::model::GetOperationRequest,
316        _options: crate::RequestOptions,
317    ) -> impl std::future::Future<
318        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
319    > + Send {
320        gaxi::unimplemented::unimplemented_stub()
321    }
322
323    /// Returns the polling error policy.
324    ///
325    /// When mocking, this method is typically irrelevant. Do not try to verify
326    /// it is called by your mocks.
327    fn get_polling_error_policy(
328        &self,
329        _options: &crate::RequestOptions,
330    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
331        std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
332    }
333
334    /// Returns the polling backoff policy.
335    ///
336    /// When mocking, this method is typically irrelevant. Do not try to verify
337    /// it is called by your mocks.
338    fn get_polling_backoff_policy(
339        &self,
340        _options: &crate::RequestOptions,
341    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
342        std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
343    }
344}
345
346/// Defines the trait used to implement [super::client::Instances].
347///
348/// Application developers may need to implement this trait to mock
349/// `client::Instances`.  In other use-cases, application developers only
350/// use `client::Instances` and need not be concerned with this trait or
351/// its implementations.
352///
353/// Services gain new RPCs routinely. Consequently, this trait gains new methods
354/// too. To avoid breaking applications the trait provides a default
355/// implementation of each method. Most of these implementations just return an
356/// error.
357pub trait Instances: std::fmt::Debug + Send + Sync {
358    /// Implements [super::client::Instances::list_instances].
359    fn list_instances(
360        &self,
361        _req: crate::model::ListInstancesRequest,
362        _options: crate::RequestOptions,
363    ) -> impl std::future::Future<
364        Output = crate::Result<crate::Response<crate::model::ListInstancesResponse>>,
365    > + Send {
366        gaxi::unimplemented::unimplemented_stub()
367    }
368
369    /// Implements [super::client::Instances::get_instance].
370    fn get_instance(
371        &self,
372        _req: crate::model::GetInstanceRequest,
373        _options: crate::RequestOptions,
374    ) -> impl std::future::Future<Output = crate::Result<crate::Response<crate::model::Instance>>> + Send
375    {
376        gaxi::unimplemented::unimplemented_stub()
377    }
378
379    /// Implements [super::client::Instances::delete_instance].
380    fn delete_instance(
381        &self,
382        _req: crate::model::DeleteInstanceRequest,
383        _options: crate::RequestOptions,
384    ) -> impl std::future::Future<
385        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
386    > + Send {
387        gaxi::unimplemented::unimplemented_stub()
388    }
389
390    /// Implements [super::client::Instances::debug_instance].
391    fn debug_instance(
392        &self,
393        _req: crate::model::DebugInstanceRequest,
394        _options: crate::RequestOptions,
395    ) -> impl std::future::Future<
396        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
397    > + Send {
398        gaxi::unimplemented::unimplemented_stub()
399    }
400
401    /// Implements [super::client::Instances::list_operations].
402    fn list_operations(
403        &self,
404        _req: google_cloud_longrunning::model::ListOperationsRequest,
405        _options: crate::RequestOptions,
406    ) -> impl std::future::Future<
407        Output = crate::Result<
408            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
409        >,
410    > + Send {
411        gaxi::unimplemented::unimplemented_stub()
412    }
413
414    /// Implements [super::client::Instances::get_operation].
415    fn get_operation(
416        &self,
417        _req: google_cloud_longrunning::model::GetOperationRequest,
418        _options: crate::RequestOptions,
419    ) -> impl std::future::Future<
420        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
421    > + Send {
422        gaxi::unimplemented::unimplemented_stub()
423    }
424
425    /// Returns the polling error policy.
426    ///
427    /// When mocking, this method is typically irrelevant. Do not try to verify
428    /// it is called by your mocks.
429    fn get_polling_error_policy(
430        &self,
431        _options: &crate::RequestOptions,
432    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
433        std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
434    }
435
436    /// Returns the polling backoff policy.
437    ///
438    /// When mocking, this method is typically irrelevant. Do not try to verify
439    /// it is called by your mocks.
440    fn get_polling_backoff_policy(
441        &self,
442        _options: &crate::RequestOptions,
443    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
444        std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
445    }
446}
447
448/// Defines the trait used to implement [super::client::Firewall].
449///
450/// Application developers may need to implement this trait to mock
451/// `client::Firewall`.  In other use-cases, application developers only
452/// use `client::Firewall` and need not be concerned with this trait or
453/// its implementations.
454///
455/// Services gain new RPCs routinely. Consequently, this trait gains new methods
456/// too. To avoid breaking applications the trait provides a default
457/// implementation of each method. Most of these implementations just return an
458/// error.
459pub trait Firewall: std::fmt::Debug + Send + Sync {
460    /// Implements [super::client::Firewall::list_ingress_rules].
461    fn list_ingress_rules(
462        &self,
463        _req: crate::model::ListIngressRulesRequest,
464        _options: crate::RequestOptions,
465    ) -> impl std::future::Future<
466        Output = crate::Result<crate::Response<crate::model::ListIngressRulesResponse>>,
467    > + Send {
468        gaxi::unimplemented::unimplemented_stub()
469    }
470
471    /// Implements [super::client::Firewall::batch_update_ingress_rules].
472    fn batch_update_ingress_rules(
473        &self,
474        _req: crate::model::BatchUpdateIngressRulesRequest,
475        _options: crate::RequestOptions,
476    ) -> impl std::future::Future<
477        Output = crate::Result<crate::Response<crate::model::BatchUpdateIngressRulesResponse>>,
478    > + Send {
479        gaxi::unimplemented::unimplemented_stub()
480    }
481
482    /// Implements [super::client::Firewall::create_ingress_rule].
483    fn create_ingress_rule(
484        &self,
485        _req: crate::model::CreateIngressRuleRequest,
486        _options: crate::RequestOptions,
487    ) -> impl std::future::Future<
488        Output = crate::Result<crate::Response<crate::model::FirewallRule>>,
489    > + Send {
490        gaxi::unimplemented::unimplemented_stub()
491    }
492
493    /// Implements [super::client::Firewall::get_ingress_rule].
494    fn get_ingress_rule(
495        &self,
496        _req: crate::model::GetIngressRuleRequest,
497        _options: crate::RequestOptions,
498    ) -> impl std::future::Future<
499        Output = crate::Result<crate::Response<crate::model::FirewallRule>>,
500    > + Send {
501        gaxi::unimplemented::unimplemented_stub()
502    }
503
504    /// Implements [super::client::Firewall::update_ingress_rule].
505    fn update_ingress_rule(
506        &self,
507        _req: crate::model::UpdateIngressRuleRequest,
508        _options: crate::RequestOptions,
509    ) -> impl std::future::Future<
510        Output = crate::Result<crate::Response<crate::model::FirewallRule>>,
511    > + Send {
512        gaxi::unimplemented::unimplemented_stub()
513    }
514
515    /// Implements [super::client::Firewall::delete_ingress_rule].
516    fn delete_ingress_rule(
517        &self,
518        _req: crate::model::DeleteIngressRuleRequest,
519        _options: crate::RequestOptions,
520    ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
521        gaxi::unimplemented::unimplemented_stub()
522    }
523
524    /// Implements [super::client::Firewall::list_operations].
525    fn list_operations(
526        &self,
527        _req: google_cloud_longrunning::model::ListOperationsRequest,
528        _options: crate::RequestOptions,
529    ) -> impl std::future::Future<
530        Output = crate::Result<
531            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
532        >,
533    > + Send {
534        gaxi::unimplemented::unimplemented_stub()
535    }
536
537    /// Implements [super::client::Firewall::get_operation].
538    fn get_operation(
539        &self,
540        _req: google_cloud_longrunning::model::GetOperationRequest,
541        _options: crate::RequestOptions,
542    ) -> impl std::future::Future<
543        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
544    > + Send {
545        gaxi::unimplemented::unimplemented_stub()
546    }
547}
548
549/// Defines the trait used to implement [super::client::AuthorizedDomains].
550///
551/// Application developers may need to implement this trait to mock
552/// `client::AuthorizedDomains`.  In other use-cases, application developers only
553/// use `client::AuthorizedDomains` and need not be concerned with this trait or
554/// its implementations.
555///
556/// Services gain new RPCs routinely. Consequently, this trait gains new methods
557/// too. To avoid breaking applications the trait provides a default
558/// implementation of each method. Most of these implementations just return an
559/// error.
560pub trait AuthorizedDomains: std::fmt::Debug + Send + Sync {
561    /// Implements [super::client::AuthorizedDomains::list_authorized_domains].
562    fn list_authorized_domains(
563        &self,
564        _req: crate::model::ListAuthorizedDomainsRequest,
565        _options: crate::RequestOptions,
566    ) -> impl std::future::Future<
567        Output = crate::Result<crate::Response<crate::model::ListAuthorizedDomainsResponse>>,
568    > + Send {
569        gaxi::unimplemented::unimplemented_stub()
570    }
571
572    /// Implements [super::client::AuthorizedDomains::list_operations].
573    fn list_operations(
574        &self,
575        _req: google_cloud_longrunning::model::ListOperationsRequest,
576        _options: crate::RequestOptions,
577    ) -> impl std::future::Future<
578        Output = crate::Result<
579            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
580        >,
581    > + Send {
582        gaxi::unimplemented::unimplemented_stub()
583    }
584
585    /// Implements [super::client::AuthorizedDomains::get_operation].
586    fn get_operation(
587        &self,
588        _req: google_cloud_longrunning::model::GetOperationRequest,
589        _options: crate::RequestOptions,
590    ) -> impl std::future::Future<
591        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
592    > + Send {
593        gaxi::unimplemented::unimplemented_stub()
594    }
595}
596
597/// Defines the trait used to implement [super::client::AuthorizedCertificates].
598///
599/// Application developers may need to implement this trait to mock
600/// `client::AuthorizedCertificates`.  In other use-cases, application developers only
601/// use `client::AuthorizedCertificates` and need not be concerned with this trait or
602/// its implementations.
603///
604/// Services gain new RPCs routinely. Consequently, this trait gains new methods
605/// too. To avoid breaking applications the trait provides a default
606/// implementation of each method. Most of these implementations just return an
607/// error.
608pub trait AuthorizedCertificates: std::fmt::Debug + Send + Sync {
609    /// Implements [super::client::AuthorizedCertificates::list_authorized_certificates].
610    fn list_authorized_certificates(
611        &self,
612        _req: crate::model::ListAuthorizedCertificatesRequest,
613        _options: crate::RequestOptions,
614    ) -> impl std::future::Future<
615        Output = crate::Result<crate::Response<crate::model::ListAuthorizedCertificatesResponse>>,
616    > + Send {
617        gaxi::unimplemented::unimplemented_stub()
618    }
619
620    /// Implements [super::client::AuthorizedCertificates::get_authorized_certificate].
621    fn get_authorized_certificate(
622        &self,
623        _req: crate::model::GetAuthorizedCertificateRequest,
624        _options: crate::RequestOptions,
625    ) -> impl std::future::Future<
626        Output = crate::Result<crate::Response<crate::model::AuthorizedCertificate>>,
627    > + Send {
628        gaxi::unimplemented::unimplemented_stub()
629    }
630
631    /// Implements [super::client::AuthorizedCertificates::create_authorized_certificate].
632    fn create_authorized_certificate(
633        &self,
634        _req: crate::model::CreateAuthorizedCertificateRequest,
635        _options: crate::RequestOptions,
636    ) -> impl std::future::Future<
637        Output = crate::Result<crate::Response<crate::model::AuthorizedCertificate>>,
638    > + Send {
639        gaxi::unimplemented::unimplemented_stub()
640    }
641
642    /// Implements [super::client::AuthorizedCertificates::update_authorized_certificate].
643    fn update_authorized_certificate(
644        &self,
645        _req: crate::model::UpdateAuthorizedCertificateRequest,
646        _options: crate::RequestOptions,
647    ) -> impl std::future::Future<
648        Output = crate::Result<crate::Response<crate::model::AuthorizedCertificate>>,
649    > + Send {
650        gaxi::unimplemented::unimplemented_stub()
651    }
652
653    /// Implements [super::client::AuthorizedCertificates::delete_authorized_certificate].
654    fn delete_authorized_certificate(
655        &self,
656        _req: crate::model::DeleteAuthorizedCertificateRequest,
657        _options: crate::RequestOptions,
658    ) -> impl std::future::Future<Output = crate::Result<crate::Response<()>>> + Send {
659        gaxi::unimplemented::unimplemented_stub()
660    }
661
662    /// Implements [super::client::AuthorizedCertificates::list_operations].
663    fn list_operations(
664        &self,
665        _req: google_cloud_longrunning::model::ListOperationsRequest,
666        _options: crate::RequestOptions,
667    ) -> impl std::future::Future<
668        Output = crate::Result<
669            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
670        >,
671    > + Send {
672        gaxi::unimplemented::unimplemented_stub()
673    }
674
675    /// Implements [super::client::AuthorizedCertificates::get_operation].
676    fn get_operation(
677        &self,
678        _req: google_cloud_longrunning::model::GetOperationRequest,
679        _options: crate::RequestOptions,
680    ) -> impl std::future::Future<
681        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
682    > + Send {
683        gaxi::unimplemented::unimplemented_stub()
684    }
685}
686
687/// Defines the trait used to implement [super::client::DomainMappings].
688///
689/// Application developers may need to implement this trait to mock
690/// `client::DomainMappings`.  In other use-cases, application developers only
691/// use `client::DomainMappings` and need not be concerned with this trait or
692/// its implementations.
693///
694/// Services gain new RPCs routinely. Consequently, this trait gains new methods
695/// too. To avoid breaking applications the trait provides a default
696/// implementation of each method. Most of these implementations just return an
697/// error.
698pub trait DomainMappings: std::fmt::Debug + Send + Sync {
699    /// Implements [super::client::DomainMappings::list_domain_mappings].
700    fn list_domain_mappings(
701        &self,
702        _req: crate::model::ListDomainMappingsRequest,
703        _options: crate::RequestOptions,
704    ) -> impl std::future::Future<
705        Output = crate::Result<crate::Response<crate::model::ListDomainMappingsResponse>>,
706    > + Send {
707        gaxi::unimplemented::unimplemented_stub()
708    }
709
710    /// Implements [super::client::DomainMappings::get_domain_mapping].
711    fn get_domain_mapping(
712        &self,
713        _req: crate::model::GetDomainMappingRequest,
714        _options: crate::RequestOptions,
715    ) -> impl std::future::Future<
716        Output = crate::Result<crate::Response<crate::model::DomainMapping>>,
717    > + Send {
718        gaxi::unimplemented::unimplemented_stub()
719    }
720
721    /// Implements [super::client::DomainMappings::create_domain_mapping].
722    fn create_domain_mapping(
723        &self,
724        _req: crate::model::CreateDomainMappingRequest,
725        _options: crate::RequestOptions,
726    ) -> impl std::future::Future<
727        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
728    > + Send {
729        gaxi::unimplemented::unimplemented_stub()
730    }
731
732    /// Implements [super::client::DomainMappings::update_domain_mapping].
733    fn update_domain_mapping(
734        &self,
735        _req: crate::model::UpdateDomainMappingRequest,
736        _options: crate::RequestOptions,
737    ) -> impl std::future::Future<
738        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
739    > + Send {
740        gaxi::unimplemented::unimplemented_stub()
741    }
742
743    /// Implements [super::client::DomainMappings::delete_domain_mapping].
744    fn delete_domain_mapping(
745        &self,
746        _req: crate::model::DeleteDomainMappingRequest,
747        _options: crate::RequestOptions,
748    ) -> impl std::future::Future<
749        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
750    > + Send {
751        gaxi::unimplemented::unimplemented_stub()
752    }
753
754    /// Implements [super::client::DomainMappings::list_operations].
755    fn list_operations(
756        &self,
757        _req: google_cloud_longrunning::model::ListOperationsRequest,
758        _options: crate::RequestOptions,
759    ) -> impl std::future::Future<
760        Output = crate::Result<
761            crate::Response<google_cloud_longrunning::model::ListOperationsResponse>,
762        >,
763    > + Send {
764        gaxi::unimplemented::unimplemented_stub()
765    }
766
767    /// Implements [super::client::DomainMappings::get_operation].
768    fn get_operation(
769        &self,
770        _req: google_cloud_longrunning::model::GetOperationRequest,
771        _options: crate::RequestOptions,
772    ) -> impl std::future::Future<
773        Output = crate::Result<crate::Response<google_cloud_longrunning::model::Operation>>,
774    > + Send {
775        gaxi::unimplemented::unimplemented_stub()
776    }
777
778    /// Returns the polling error policy.
779    ///
780    /// When mocking, this method is typically irrelevant. Do not try to verify
781    /// it is called by your mocks.
782    fn get_polling_error_policy(
783        &self,
784        _options: &crate::RequestOptions,
785    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
786        std::sync::Arc::new(google_cloud_gax::polling_error_policy::Aip194Strict)
787    }
788
789    /// Returns the polling backoff policy.
790    ///
791    /// When mocking, this method is typically irrelevant. Do not try to verify
792    /// it is called by your mocks.
793    fn get_polling_backoff_policy(
794        &self,
795        _options: &crate::RequestOptions,
796    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
797        std::sync::Arc::new(google_cloud_gax::exponential_backoff::ExponentialBackoff::default())
798    }
799}