zitadel/api/generated/
zitadel.auth.v1.tonic.rs

1// @generated
2/// Generated client implementations.
3pub mod auth_service_client {
4    #![allow(
5        unused_variables,
6        dead_code,
7        missing_docs,
8        clippy::wildcard_imports,
9        clippy::let_unit_value,
10    )]
11    use tonic::codegen::*;
12    use tonic::codegen::http::Uri;
13    #[derive(Debug, Clone)]
14    pub struct AuthServiceClient<T> {
15        inner: tonic::client::Grpc<T>,
16    }
17    impl AuthServiceClient<tonic::transport::Channel> {
18        /// Attempt to create a new client by connecting to a given endpoint.
19        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
20        where
21            D: TryInto<tonic::transport::Endpoint>,
22            D::Error: Into<StdError>,
23        {
24            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
25            Ok(Self::new(conn))
26        }
27    }
28    impl<T> AuthServiceClient<T>
29    where
30        T: tonic::client::GrpcService<tonic::body::BoxBody>,
31        T::Error: Into<StdError>,
32        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
33        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
34    {
35        pub fn new(inner: T) -> Self {
36            let inner = tonic::client::Grpc::new(inner);
37            Self { inner }
38        }
39        pub fn with_origin(inner: T, origin: Uri) -> Self {
40            let inner = tonic::client::Grpc::with_origin(inner, origin);
41            Self { inner }
42        }
43        pub fn with_interceptor<F>(
44            inner: T,
45            interceptor: F,
46        ) -> AuthServiceClient<InterceptedService<T, F>>
47        where
48            F: tonic::service::Interceptor,
49            T::ResponseBody: Default,
50            T: tonic::codegen::Service<
51                http::Request<tonic::body::BoxBody>,
52                Response = http::Response<
53                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
54                >,
55            >,
56            <T as tonic::codegen::Service<
57                http::Request<tonic::body::BoxBody>,
58            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
59        {
60            AuthServiceClient::new(InterceptedService::new(inner, interceptor))
61        }
62        /// Compress requests with the given encoding.
63        ///
64        /// This requires the server to support it otherwise it might respond with an
65        /// error.
66        #[must_use]
67        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
68            self.inner = self.inner.send_compressed(encoding);
69            self
70        }
71        /// Enable decompressing responses.
72        #[must_use]
73        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
74            self.inner = self.inner.accept_compressed(encoding);
75            self
76        }
77        /// Limits the maximum size of a decoded message.
78        ///
79        /// Default: `4MB`
80        #[must_use]
81        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
82            self.inner = self.inner.max_decoding_message_size(limit);
83            self
84        }
85        /// Limits the maximum size of an encoded message.
86        ///
87        /// Default: `usize::MAX`
88        #[must_use]
89        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
90            self.inner = self.inner.max_encoding_message_size(limit);
91            self
92        }
93        pub async fn healthz(
94            &mut self,
95            request: impl tonic::IntoRequest<super::HealthzRequest>,
96        ) -> std::result::Result<
97            tonic::Response<super::HealthzResponse>,
98            tonic::Status,
99        > {
100            self.inner
101                .ready()
102                .await
103                .map_err(|e| {
104                    tonic::Status::unknown(
105                        format!("Service was not ready: {}", e.into()),
106                    )
107                })?;
108            let codec = tonic::codec::ProstCodec::default();
109            let path = http::uri::PathAndQuery::from_static(
110                "/zitadel.auth.v1.AuthService/Healthz",
111            );
112            let mut req = request.into_request();
113            req.extensions_mut()
114                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "Healthz"));
115            self.inner.unary(req, path, codec).await
116        }
117        pub async fn get_supported_languages(
118            &mut self,
119            request: impl tonic::IntoRequest<super::GetSupportedLanguagesRequest>,
120        ) -> std::result::Result<
121            tonic::Response<super::GetSupportedLanguagesResponse>,
122            tonic::Status,
123        > {
124            self.inner
125                .ready()
126                .await
127                .map_err(|e| {
128                    tonic::Status::unknown(
129                        format!("Service was not ready: {}", e.into()),
130                    )
131                })?;
132            let codec = tonic::codec::ProstCodec::default();
133            let path = http::uri::PathAndQuery::from_static(
134                "/zitadel.auth.v1.AuthService/GetSupportedLanguages",
135            );
136            let mut req = request.into_request();
137            req.extensions_mut()
138                .insert(
139                    GrpcMethod::new(
140                        "zitadel.auth.v1.AuthService",
141                        "GetSupportedLanguages",
142                    ),
143                );
144            self.inner.unary(req, path, codec).await
145        }
146        pub async fn get_my_user(
147            &mut self,
148            request: impl tonic::IntoRequest<super::GetMyUserRequest>,
149        ) -> std::result::Result<
150            tonic::Response<super::GetMyUserResponse>,
151            tonic::Status,
152        > {
153            self.inner
154                .ready()
155                .await
156                .map_err(|e| {
157                    tonic::Status::unknown(
158                        format!("Service was not ready: {}", e.into()),
159                    )
160                })?;
161            let codec = tonic::codec::ProstCodec::default();
162            let path = http::uri::PathAndQuery::from_static(
163                "/zitadel.auth.v1.AuthService/GetMyUser",
164            );
165            let mut req = request.into_request();
166            req.extensions_mut()
167                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyUser"));
168            self.inner.unary(req, path, codec).await
169        }
170        pub async fn remove_my_user(
171            &mut self,
172            request: impl tonic::IntoRequest<super::RemoveMyUserRequest>,
173        ) -> std::result::Result<
174            tonic::Response<super::RemoveMyUserResponse>,
175            tonic::Status,
176        > {
177            self.inner
178                .ready()
179                .await
180                .map_err(|e| {
181                    tonic::Status::unknown(
182                        format!("Service was not ready: {}", e.into()),
183                    )
184                })?;
185            let codec = tonic::codec::ProstCodec::default();
186            let path = http::uri::PathAndQuery::from_static(
187                "/zitadel.auth.v1.AuthService/RemoveMyUser",
188            );
189            let mut req = request.into_request();
190            req.extensions_mut()
191                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "RemoveMyUser"));
192            self.inner.unary(req, path, codec).await
193        }
194        pub async fn list_my_user_changes(
195            &mut self,
196            request: impl tonic::IntoRequest<super::ListMyUserChangesRequest>,
197        ) -> std::result::Result<
198            tonic::Response<super::ListMyUserChangesResponse>,
199            tonic::Status,
200        > {
201            self.inner
202                .ready()
203                .await
204                .map_err(|e| {
205                    tonic::Status::unknown(
206                        format!("Service was not ready: {}", e.into()),
207                    )
208                })?;
209            let codec = tonic::codec::ProstCodec::default();
210            let path = http::uri::PathAndQuery::from_static(
211                "/zitadel.auth.v1.AuthService/ListMyUserChanges",
212            );
213            let mut req = request.into_request();
214            req.extensions_mut()
215                .insert(
216                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyUserChanges"),
217                );
218            self.inner.unary(req, path, codec).await
219        }
220        pub async fn list_my_user_sessions(
221            &mut self,
222            request: impl tonic::IntoRequest<super::ListMyUserSessionsRequest>,
223        ) -> std::result::Result<
224            tonic::Response<super::ListMyUserSessionsResponse>,
225            tonic::Status,
226        > {
227            self.inner
228                .ready()
229                .await
230                .map_err(|e| {
231                    tonic::Status::unknown(
232                        format!("Service was not ready: {}", e.into()),
233                    )
234                })?;
235            let codec = tonic::codec::ProstCodec::default();
236            let path = http::uri::PathAndQuery::from_static(
237                "/zitadel.auth.v1.AuthService/ListMyUserSessions",
238            );
239            let mut req = request.into_request();
240            req.extensions_mut()
241                .insert(
242                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyUserSessions"),
243                );
244            self.inner.unary(req, path, codec).await
245        }
246        pub async fn list_my_metadata(
247            &mut self,
248            request: impl tonic::IntoRequest<super::ListMyMetadataRequest>,
249        ) -> std::result::Result<
250            tonic::Response<super::ListMyMetadataResponse>,
251            tonic::Status,
252        > {
253            self.inner
254                .ready()
255                .await
256                .map_err(|e| {
257                    tonic::Status::unknown(
258                        format!("Service was not ready: {}", e.into()),
259                    )
260                })?;
261            let codec = tonic::codec::ProstCodec::default();
262            let path = http::uri::PathAndQuery::from_static(
263                "/zitadel.auth.v1.AuthService/ListMyMetadata",
264            );
265            let mut req = request.into_request();
266            req.extensions_mut()
267                .insert(
268                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyMetadata"),
269                );
270            self.inner.unary(req, path, codec).await
271        }
272        pub async fn get_my_metadata(
273            &mut self,
274            request: impl tonic::IntoRequest<super::GetMyMetadataRequest>,
275        ) -> std::result::Result<
276            tonic::Response<super::GetMyMetadataResponse>,
277            tonic::Status,
278        > {
279            self.inner
280                .ready()
281                .await
282                .map_err(|e| {
283                    tonic::Status::unknown(
284                        format!("Service was not ready: {}", e.into()),
285                    )
286                })?;
287            let codec = tonic::codec::ProstCodec::default();
288            let path = http::uri::PathAndQuery::from_static(
289                "/zitadel.auth.v1.AuthService/GetMyMetadata",
290            );
291            let mut req = request.into_request();
292            req.extensions_mut()
293                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyMetadata"));
294            self.inner.unary(req, path, codec).await
295        }
296        pub async fn list_my_refresh_tokens(
297            &mut self,
298            request: impl tonic::IntoRequest<super::ListMyRefreshTokensRequest>,
299        ) -> std::result::Result<
300            tonic::Response<super::ListMyRefreshTokensResponse>,
301            tonic::Status,
302        > {
303            self.inner
304                .ready()
305                .await
306                .map_err(|e| {
307                    tonic::Status::unknown(
308                        format!("Service was not ready: {}", e.into()),
309                    )
310                })?;
311            let codec = tonic::codec::ProstCodec::default();
312            let path = http::uri::PathAndQuery::from_static(
313                "/zitadel.auth.v1.AuthService/ListMyRefreshTokens",
314            );
315            let mut req = request.into_request();
316            req.extensions_mut()
317                .insert(
318                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyRefreshTokens"),
319                );
320            self.inner.unary(req, path, codec).await
321        }
322        pub async fn revoke_my_refresh_token(
323            &mut self,
324            request: impl tonic::IntoRequest<super::RevokeMyRefreshTokenRequest>,
325        ) -> std::result::Result<
326            tonic::Response<super::RevokeMyRefreshTokenResponse>,
327            tonic::Status,
328        > {
329            self.inner
330                .ready()
331                .await
332                .map_err(|e| {
333                    tonic::Status::unknown(
334                        format!("Service was not ready: {}", e.into()),
335                    )
336                })?;
337            let codec = tonic::codec::ProstCodec::default();
338            let path = http::uri::PathAndQuery::from_static(
339                "/zitadel.auth.v1.AuthService/RevokeMyRefreshToken",
340            );
341            let mut req = request.into_request();
342            req.extensions_mut()
343                .insert(
344                    GrpcMethod::new(
345                        "zitadel.auth.v1.AuthService",
346                        "RevokeMyRefreshToken",
347                    ),
348                );
349            self.inner.unary(req, path, codec).await
350        }
351        pub async fn revoke_all_my_refresh_tokens(
352            &mut self,
353            request: impl tonic::IntoRequest<super::RevokeAllMyRefreshTokensRequest>,
354        ) -> std::result::Result<
355            tonic::Response<super::RevokeAllMyRefreshTokensResponse>,
356            tonic::Status,
357        > {
358            self.inner
359                .ready()
360                .await
361                .map_err(|e| {
362                    tonic::Status::unknown(
363                        format!("Service was not ready: {}", e.into()),
364                    )
365                })?;
366            let codec = tonic::codec::ProstCodec::default();
367            let path = http::uri::PathAndQuery::from_static(
368                "/zitadel.auth.v1.AuthService/RevokeAllMyRefreshTokens",
369            );
370            let mut req = request.into_request();
371            req.extensions_mut()
372                .insert(
373                    GrpcMethod::new(
374                        "zitadel.auth.v1.AuthService",
375                        "RevokeAllMyRefreshTokens",
376                    ),
377                );
378            self.inner.unary(req, path, codec).await
379        }
380        pub async fn update_my_user_name(
381            &mut self,
382            request: impl tonic::IntoRequest<super::UpdateMyUserNameRequest>,
383        ) -> std::result::Result<
384            tonic::Response<super::UpdateMyUserNameResponse>,
385            tonic::Status,
386        > {
387            self.inner
388                .ready()
389                .await
390                .map_err(|e| {
391                    tonic::Status::unknown(
392                        format!("Service was not ready: {}", e.into()),
393                    )
394                })?;
395            let codec = tonic::codec::ProstCodec::default();
396            let path = http::uri::PathAndQuery::from_static(
397                "/zitadel.auth.v1.AuthService/UpdateMyUserName",
398            );
399            let mut req = request.into_request();
400            req.extensions_mut()
401                .insert(
402                    GrpcMethod::new("zitadel.auth.v1.AuthService", "UpdateMyUserName"),
403                );
404            self.inner.unary(req, path, codec).await
405        }
406        pub async fn get_my_password_complexity_policy(
407            &mut self,
408            request: impl tonic::IntoRequest<super::GetMyPasswordComplexityPolicyRequest>,
409        ) -> std::result::Result<
410            tonic::Response<super::GetMyPasswordComplexityPolicyResponse>,
411            tonic::Status,
412        > {
413            self.inner
414                .ready()
415                .await
416                .map_err(|e| {
417                    tonic::Status::unknown(
418                        format!("Service was not ready: {}", e.into()),
419                    )
420                })?;
421            let codec = tonic::codec::ProstCodec::default();
422            let path = http::uri::PathAndQuery::from_static(
423                "/zitadel.auth.v1.AuthService/GetMyPasswordComplexityPolicy",
424            );
425            let mut req = request.into_request();
426            req.extensions_mut()
427                .insert(
428                    GrpcMethod::new(
429                        "zitadel.auth.v1.AuthService",
430                        "GetMyPasswordComplexityPolicy",
431                    ),
432                );
433            self.inner.unary(req, path, codec).await
434        }
435        pub async fn update_my_password(
436            &mut self,
437            request: impl tonic::IntoRequest<super::UpdateMyPasswordRequest>,
438        ) -> std::result::Result<
439            tonic::Response<super::UpdateMyPasswordResponse>,
440            tonic::Status,
441        > {
442            self.inner
443                .ready()
444                .await
445                .map_err(|e| {
446                    tonic::Status::unknown(
447                        format!("Service was not ready: {}", e.into()),
448                    )
449                })?;
450            let codec = tonic::codec::ProstCodec::default();
451            let path = http::uri::PathAndQuery::from_static(
452                "/zitadel.auth.v1.AuthService/UpdateMyPassword",
453            );
454            let mut req = request.into_request();
455            req.extensions_mut()
456                .insert(
457                    GrpcMethod::new("zitadel.auth.v1.AuthService", "UpdateMyPassword"),
458                );
459            self.inner.unary(req, path, codec).await
460        }
461        pub async fn get_my_profile(
462            &mut self,
463            request: impl tonic::IntoRequest<super::GetMyProfileRequest>,
464        ) -> std::result::Result<
465            tonic::Response<super::GetMyProfileResponse>,
466            tonic::Status,
467        > {
468            self.inner
469                .ready()
470                .await
471                .map_err(|e| {
472                    tonic::Status::unknown(
473                        format!("Service was not ready: {}", e.into()),
474                    )
475                })?;
476            let codec = tonic::codec::ProstCodec::default();
477            let path = http::uri::PathAndQuery::from_static(
478                "/zitadel.auth.v1.AuthService/GetMyProfile",
479            );
480            let mut req = request.into_request();
481            req.extensions_mut()
482                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyProfile"));
483            self.inner.unary(req, path, codec).await
484        }
485        pub async fn update_my_profile(
486            &mut self,
487            request: impl tonic::IntoRequest<super::UpdateMyProfileRequest>,
488        ) -> std::result::Result<
489            tonic::Response<super::UpdateMyProfileResponse>,
490            tonic::Status,
491        > {
492            self.inner
493                .ready()
494                .await
495                .map_err(|e| {
496                    tonic::Status::unknown(
497                        format!("Service was not ready: {}", e.into()),
498                    )
499                })?;
500            let codec = tonic::codec::ProstCodec::default();
501            let path = http::uri::PathAndQuery::from_static(
502                "/zitadel.auth.v1.AuthService/UpdateMyProfile",
503            );
504            let mut req = request.into_request();
505            req.extensions_mut()
506                .insert(
507                    GrpcMethod::new("zitadel.auth.v1.AuthService", "UpdateMyProfile"),
508                );
509            self.inner.unary(req, path, codec).await
510        }
511        pub async fn get_my_email(
512            &mut self,
513            request: impl tonic::IntoRequest<super::GetMyEmailRequest>,
514        ) -> std::result::Result<
515            tonic::Response<super::GetMyEmailResponse>,
516            tonic::Status,
517        > {
518            self.inner
519                .ready()
520                .await
521                .map_err(|e| {
522                    tonic::Status::unknown(
523                        format!("Service was not ready: {}", e.into()),
524                    )
525                })?;
526            let codec = tonic::codec::ProstCodec::default();
527            let path = http::uri::PathAndQuery::from_static(
528                "/zitadel.auth.v1.AuthService/GetMyEmail",
529            );
530            let mut req = request.into_request();
531            req.extensions_mut()
532                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyEmail"));
533            self.inner.unary(req, path, codec).await
534        }
535        pub async fn set_my_email(
536            &mut self,
537            request: impl tonic::IntoRequest<super::SetMyEmailRequest>,
538        ) -> std::result::Result<
539            tonic::Response<super::SetMyEmailResponse>,
540            tonic::Status,
541        > {
542            self.inner
543                .ready()
544                .await
545                .map_err(|e| {
546                    tonic::Status::unknown(
547                        format!("Service was not ready: {}", e.into()),
548                    )
549                })?;
550            let codec = tonic::codec::ProstCodec::default();
551            let path = http::uri::PathAndQuery::from_static(
552                "/zitadel.auth.v1.AuthService/SetMyEmail",
553            );
554            let mut req = request.into_request();
555            req.extensions_mut()
556                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "SetMyEmail"));
557            self.inner.unary(req, path, codec).await
558        }
559        pub async fn verify_my_email(
560            &mut self,
561            request: impl tonic::IntoRequest<super::VerifyMyEmailRequest>,
562        ) -> std::result::Result<
563            tonic::Response<super::VerifyMyEmailResponse>,
564            tonic::Status,
565        > {
566            self.inner
567                .ready()
568                .await
569                .map_err(|e| {
570                    tonic::Status::unknown(
571                        format!("Service was not ready: {}", e.into()),
572                    )
573                })?;
574            let codec = tonic::codec::ProstCodec::default();
575            let path = http::uri::PathAndQuery::from_static(
576                "/zitadel.auth.v1.AuthService/VerifyMyEmail",
577            );
578            let mut req = request.into_request();
579            req.extensions_mut()
580                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "VerifyMyEmail"));
581            self.inner.unary(req, path, codec).await
582        }
583        pub async fn resend_my_email_verification(
584            &mut self,
585            request: impl tonic::IntoRequest<super::ResendMyEmailVerificationRequest>,
586        ) -> std::result::Result<
587            tonic::Response<super::ResendMyEmailVerificationResponse>,
588            tonic::Status,
589        > {
590            self.inner
591                .ready()
592                .await
593                .map_err(|e| {
594                    tonic::Status::unknown(
595                        format!("Service was not ready: {}", e.into()),
596                    )
597                })?;
598            let codec = tonic::codec::ProstCodec::default();
599            let path = http::uri::PathAndQuery::from_static(
600                "/zitadel.auth.v1.AuthService/ResendMyEmailVerification",
601            );
602            let mut req = request.into_request();
603            req.extensions_mut()
604                .insert(
605                    GrpcMethod::new(
606                        "zitadel.auth.v1.AuthService",
607                        "ResendMyEmailVerification",
608                    ),
609                );
610            self.inner.unary(req, path, codec).await
611        }
612        pub async fn get_my_phone(
613            &mut self,
614            request: impl tonic::IntoRequest<super::GetMyPhoneRequest>,
615        ) -> std::result::Result<
616            tonic::Response<super::GetMyPhoneResponse>,
617            tonic::Status,
618        > {
619            self.inner
620                .ready()
621                .await
622                .map_err(|e| {
623                    tonic::Status::unknown(
624                        format!("Service was not ready: {}", e.into()),
625                    )
626                })?;
627            let codec = tonic::codec::ProstCodec::default();
628            let path = http::uri::PathAndQuery::from_static(
629                "/zitadel.auth.v1.AuthService/GetMyPhone",
630            );
631            let mut req = request.into_request();
632            req.extensions_mut()
633                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyPhone"));
634            self.inner.unary(req, path, codec).await
635        }
636        pub async fn set_my_phone(
637            &mut self,
638            request: impl tonic::IntoRequest<super::SetMyPhoneRequest>,
639        ) -> std::result::Result<
640            tonic::Response<super::SetMyPhoneResponse>,
641            tonic::Status,
642        > {
643            self.inner
644                .ready()
645                .await
646                .map_err(|e| {
647                    tonic::Status::unknown(
648                        format!("Service was not ready: {}", e.into()),
649                    )
650                })?;
651            let codec = tonic::codec::ProstCodec::default();
652            let path = http::uri::PathAndQuery::from_static(
653                "/zitadel.auth.v1.AuthService/SetMyPhone",
654            );
655            let mut req = request.into_request();
656            req.extensions_mut()
657                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "SetMyPhone"));
658            self.inner.unary(req, path, codec).await
659        }
660        pub async fn verify_my_phone(
661            &mut self,
662            request: impl tonic::IntoRequest<super::VerifyMyPhoneRequest>,
663        ) -> std::result::Result<
664            tonic::Response<super::VerifyMyPhoneResponse>,
665            tonic::Status,
666        > {
667            self.inner
668                .ready()
669                .await
670                .map_err(|e| {
671                    tonic::Status::unknown(
672                        format!("Service was not ready: {}", e.into()),
673                    )
674                })?;
675            let codec = tonic::codec::ProstCodec::default();
676            let path = http::uri::PathAndQuery::from_static(
677                "/zitadel.auth.v1.AuthService/VerifyMyPhone",
678            );
679            let mut req = request.into_request();
680            req.extensions_mut()
681                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "VerifyMyPhone"));
682            self.inner.unary(req, path, codec).await
683        }
684        pub async fn resend_my_phone_verification(
685            &mut self,
686            request: impl tonic::IntoRequest<super::ResendMyPhoneVerificationRequest>,
687        ) -> std::result::Result<
688            tonic::Response<super::ResendMyPhoneVerificationResponse>,
689            tonic::Status,
690        > {
691            self.inner
692                .ready()
693                .await
694                .map_err(|e| {
695                    tonic::Status::unknown(
696                        format!("Service was not ready: {}", e.into()),
697                    )
698                })?;
699            let codec = tonic::codec::ProstCodec::default();
700            let path = http::uri::PathAndQuery::from_static(
701                "/zitadel.auth.v1.AuthService/ResendMyPhoneVerification",
702            );
703            let mut req = request.into_request();
704            req.extensions_mut()
705                .insert(
706                    GrpcMethod::new(
707                        "zitadel.auth.v1.AuthService",
708                        "ResendMyPhoneVerification",
709                    ),
710                );
711            self.inner.unary(req, path, codec).await
712        }
713        pub async fn remove_my_phone(
714            &mut self,
715            request: impl tonic::IntoRequest<super::RemoveMyPhoneRequest>,
716        ) -> std::result::Result<
717            tonic::Response<super::RemoveMyPhoneResponse>,
718            tonic::Status,
719        > {
720            self.inner
721                .ready()
722                .await
723                .map_err(|e| {
724                    tonic::Status::unknown(
725                        format!("Service was not ready: {}", e.into()),
726                    )
727                })?;
728            let codec = tonic::codec::ProstCodec::default();
729            let path = http::uri::PathAndQuery::from_static(
730                "/zitadel.auth.v1.AuthService/RemoveMyPhone",
731            );
732            let mut req = request.into_request();
733            req.extensions_mut()
734                .insert(GrpcMethod::new("zitadel.auth.v1.AuthService", "RemoveMyPhone"));
735            self.inner.unary(req, path, codec).await
736        }
737        pub async fn remove_my_avatar(
738            &mut self,
739            request: impl tonic::IntoRequest<super::RemoveMyAvatarRequest>,
740        ) -> std::result::Result<
741            tonic::Response<super::RemoveMyAvatarResponse>,
742            tonic::Status,
743        > {
744            self.inner
745                .ready()
746                .await
747                .map_err(|e| {
748                    tonic::Status::unknown(
749                        format!("Service was not ready: {}", e.into()),
750                    )
751                })?;
752            let codec = tonic::codec::ProstCodec::default();
753            let path = http::uri::PathAndQuery::from_static(
754                "/zitadel.auth.v1.AuthService/RemoveMyAvatar",
755            );
756            let mut req = request.into_request();
757            req.extensions_mut()
758                .insert(
759                    GrpcMethod::new("zitadel.auth.v1.AuthService", "RemoveMyAvatar"),
760                );
761            self.inner.unary(req, path, codec).await
762        }
763        pub async fn list_my_linked_id_ps(
764            &mut self,
765            request: impl tonic::IntoRequest<super::ListMyLinkedIdPsRequest>,
766        ) -> std::result::Result<
767            tonic::Response<super::ListMyLinkedIdPsResponse>,
768            tonic::Status,
769        > {
770            self.inner
771                .ready()
772                .await
773                .map_err(|e| {
774                    tonic::Status::unknown(
775                        format!("Service was not ready: {}", e.into()),
776                    )
777                })?;
778            let codec = tonic::codec::ProstCodec::default();
779            let path = http::uri::PathAndQuery::from_static(
780                "/zitadel.auth.v1.AuthService/ListMyLinkedIDPs",
781            );
782            let mut req = request.into_request();
783            req.extensions_mut()
784                .insert(
785                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyLinkedIDPs"),
786                );
787            self.inner.unary(req, path, codec).await
788        }
789        pub async fn remove_my_linked_idp(
790            &mut self,
791            request: impl tonic::IntoRequest<super::RemoveMyLinkedIdpRequest>,
792        ) -> std::result::Result<
793            tonic::Response<super::RemoveMyLinkedIdpResponse>,
794            tonic::Status,
795        > {
796            self.inner
797                .ready()
798                .await
799                .map_err(|e| {
800                    tonic::Status::unknown(
801                        format!("Service was not ready: {}", e.into()),
802                    )
803                })?;
804            let codec = tonic::codec::ProstCodec::default();
805            let path = http::uri::PathAndQuery::from_static(
806                "/zitadel.auth.v1.AuthService/RemoveMyLinkedIDP",
807            );
808            let mut req = request.into_request();
809            req.extensions_mut()
810                .insert(
811                    GrpcMethod::new("zitadel.auth.v1.AuthService", "RemoveMyLinkedIDP"),
812                );
813            self.inner.unary(req, path, codec).await
814        }
815        pub async fn list_my_auth_factors(
816            &mut self,
817            request: impl tonic::IntoRequest<super::ListMyAuthFactorsRequest>,
818        ) -> std::result::Result<
819            tonic::Response<super::ListMyAuthFactorsResponse>,
820            tonic::Status,
821        > {
822            self.inner
823                .ready()
824                .await
825                .map_err(|e| {
826                    tonic::Status::unknown(
827                        format!("Service was not ready: {}", e.into()),
828                    )
829                })?;
830            let codec = tonic::codec::ProstCodec::default();
831            let path = http::uri::PathAndQuery::from_static(
832                "/zitadel.auth.v1.AuthService/ListMyAuthFactors",
833            );
834            let mut req = request.into_request();
835            req.extensions_mut()
836                .insert(
837                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyAuthFactors"),
838                );
839            self.inner.unary(req, path, codec).await
840        }
841        pub async fn add_my_auth_factor_otp(
842            &mut self,
843            request: impl tonic::IntoRequest<super::AddMyAuthFactorOtpRequest>,
844        ) -> std::result::Result<
845            tonic::Response<super::AddMyAuthFactorOtpResponse>,
846            tonic::Status,
847        > {
848            self.inner
849                .ready()
850                .await
851                .map_err(|e| {
852                    tonic::Status::unknown(
853                        format!("Service was not ready: {}", e.into()),
854                    )
855                })?;
856            let codec = tonic::codec::ProstCodec::default();
857            let path = http::uri::PathAndQuery::from_static(
858                "/zitadel.auth.v1.AuthService/AddMyAuthFactorOTP",
859            );
860            let mut req = request.into_request();
861            req.extensions_mut()
862                .insert(
863                    GrpcMethod::new("zitadel.auth.v1.AuthService", "AddMyAuthFactorOTP"),
864                );
865            self.inner.unary(req, path, codec).await
866        }
867        pub async fn verify_my_auth_factor_otp(
868            &mut self,
869            request: impl tonic::IntoRequest<super::VerifyMyAuthFactorOtpRequest>,
870        ) -> std::result::Result<
871            tonic::Response<super::VerifyMyAuthFactorOtpResponse>,
872            tonic::Status,
873        > {
874            self.inner
875                .ready()
876                .await
877                .map_err(|e| {
878                    tonic::Status::unknown(
879                        format!("Service was not ready: {}", e.into()),
880                    )
881                })?;
882            let codec = tonic::codec::ProstCodec::default();
883            let path = http::uri::PathAndQuery::from_static(
884                "/zitadel.auth.v1.AuthService/VerifyMyAuthFactorOTP",
885            );
886            let mut req = request.into_request();
887            req.extensions_mut()
888                .insert(
889                    GrpcMethod::new(
890                        "zitadel.auth.v1.AuthService",
891                        "VerifyMyAuthFactorOTP",
892                    ),
893                );
894            self.inner.unary(req, path, codec).await
895        }
896        pub async fn remove_my_auth_factor_otp(
897            &mut self,
898            request: impl tonic::IntoRequest<super::RemoveMyAuthFactorOtpRequest>,
899        ) -> std::result::Result<
900            tonic::Response<super::RemoveMyAuthFactorOtpResponse>,
901            tonic::Status,
902        > {
903            self.inner
904                .ready()
905                .await
906                .map_err(|e| {
907                    tonic::Status::unknown(
908                        format!("Service was not ready: {}", e.into()),
909                    )
910                })?;
911            let codec = tonic::codec::ProstCodec::default();
912            let path = http::uri::PathAndQuery::from_static(
913                "/zitadel.auth.v1.AuthService/RemoveMyAuthFactorOTP",
914            );
915            let mut req = request.into_request();
916            req.extensions_mut()
917                .insert(
918                    GrpcMethod::new(
919                        "zitadel.auth.v1.AuthService",
920                        "RemoveMyAuthFactorOTP",
921                    ),
922                );
923            self.inner.unary(req, path, codec).await
924        }
925        pub async fn add_my_auth_factor_otpsms(
926            &mut self,
927            request: impl tonic::IntoRequest<super::AddMyAuthFactorOtpsmsRequest>,
928        ) -> std::result::Result<
929            tonic::Response<super::AddMyAuthFactorOtpsmsResponse>,
930            tonic::Status,
931        > {
932            self.inner
933                .ready()
934                .await
935                .map_err(|e| {
936                    tonic::Status::unknown(
937                        format!("Service was not ready: {}", e.into()),
938                    )
939                })?;
940            let codec = tonic::codec::ProstCodec::default();
941            let path = http::uri::PathAndQuery::from_static(
942                "/zitadel.auth.v1.AuthService/AddMyAuthFactorOTPSMS",
943            );
944            let mut req = request.into_request();
945            req.extensions_mut()
946                .insert(
947                    GrpcMethod::new(
948                        "zitadel.auth.v1.AuthService",
949                        "AddMyAuthFactorOTPSMS",
950                    ),
951                );
952            self.inner.unary(req, path, codec).await
953        }
954        pub async fn remove_my_auth_factor_otpsms(
955            &mut self,
956            request: impl tonic::IntoRequest<super::RemoveMyAuthFactorOtpsmsRequest>,
957        ) -> std::result::Result<
958            tonic::Response<super::RemoveMyAuthFactorOtpsmsResponse>,
959            tonic::Status,
960        > {
961            self.inner
962                .ready()
963                .await
964                .map_err(|e| {
965                    tonic::Status::unknown(
966                        format!("Service was not ready: {}", e.into()),
967                    )
968                })?;
969            let codec = tonic::codec::ProstCodec::default();
970            let path = http::uri::PathAndQuery::from_static(
971                "/zitadel.auth.v1.AuthService/RemoveMyAuthFactorOTPSMS",
972            );
973            let mut req = request.into_request();
974            req.extensions_mut()
975                .insert(
976                    GrpcMethod::new(
977                        "zitadel.auth.v1.AuthService",
978                        "RemoveMyAuthFactorOTPSMS",
979                    ),
980                );
981            self.inner.unary(req, path, codec).await
982        }
983        pub async fn add_my_auth_factor_otp_email(
984            &mut self,
985            request: impl tonic::IntoRequest<super::AddMyAuthFactorOtpEmailRequest>,
986        ) -> std::result::Result<
987            tonic::Response<super::AddMyAuthFactorOtpEmailResponse>,
988            tonic::Status,
989        > {
990            self.inner
991                .ready()
992                .await
993                .map_err(|e| {
994                    tonic::Status::unknown(
995                        format!("Service was not ready: {}", e.into()),
996                    )
997                })?;
998            let codec = tonic::codec::ProstCodec::default();
999            let path = http::uri::PathAndQuery::from_static(
1000                "/zitadel.auth.v1.AuthService/AddMyAuthFactorOTPEmail",
1001            );
1002            let mut req = request.into_request();
1003            req.extensions_mut()
1004                .insert(
1005                    GrpcMethod::new(
1006                        "zitadel.auth.v1.AuthService",
1007                        "AddMyAuthFactorOTPEmail",
1008                    ),
1009                );
1010            self.inner.unary(req, path, codec).await
1011        }
1012        pub async fn remove_my_auth_factor_otp_email(
1013            &mut self,
1014            request: impl tonic::IntoRequest<super::RemoveMyAuthFactorOtpEmailRequest>,
1015        ) -> std::result::Result<
1016            tonic::Response<super::RemoveMyAuthFactorOtpEmailResponse>,
1017            tonic::Status,
1018        > {
1019            self.inner
1020                .ready()
1021                .await
1022                .map_err(|e| {
1023                    tonic::Status::unknown(
1024                        format!("Service was not ready: {}", e.into()),
1025                    )
1026                })?;
1027            let codec = tonic::codec::ProstCodec::default();
1028            let path = http::uri::PathAndQuery::from_static(
1029                "/zitadel.auth.v1.AuthService/RemoveMyAuthFactorOTPEmail",
1030            );
1031            let mut req = request.into_request();
1032            req.extensions_mut()
1033                .insert(
1034                    GrpcMethod::new(
1035                        "zitadel.auth.v1.AuthService",
1036                        "RemoveMyAuthFactorOTPEmail",
1037                    ),
1038                );
1039            self.inner.unary(req, path, codec).await
1040        }
1041        pub async fn add_my_auth_factor_u2f(
1042            &mut self,
1043            request: impl tonic::IntoRequest<super::AddMyAuthFactorU2fRequest>,
1044        ) -> std::result::Result<
1045            tonic::Response<super::AddMyAuthFactorU2fResponse>,
1046            tonic::Status,
1047        > {
1048            self.inner
1049                .ready()
1050                .await
1051                .map_err(|e| {
1052                    tonic::Status::unknown(
1053                        format!("Service was not ready: {}", e.into()),
1054                    )
1055                })?;
1056            let codec = tonic::codec::ProstCodec::default();
1057            let path = http::uri::PathAndQuery::from_static(
1058                "/zitadel.auth.v1.AuthService/AddMyAuthFactorU2F",
1059            );
1060            let mut req = request.into_request();
1061            req.extensions_mut()
1062                .insert(
1063                    GrpcMethod::new("zitadel.auth.v1.AuthService", "AddMyAuthFactorU2F"),
1064                );
1065            self.inner.unary(req, path, codec).await
1066        }
1067        pub async fn verify_my_auth_factor_u2f(
1068            &mut self,
1069            request: impl tonic::IntoRequest<super::VerifyMyAuthFactorU2fRequest>,
1070        ) -> std::result::Result<
1071            tonic::Response<super::VerifyMyAuthFactorU2fResponse>,
1072            tonic::Status,
1073        > {
1074            self.inner
1075                .ready()
1076                .await
1077                .map_err(|e| {
1078                    tonic::Status::unknown(
1079                        format!("Service was not ready: {}", e.into()),
1080                    )
1081                })?;
1082            let codec = tonic::codec::ProstCodec::default();
1083            let path = http::uri::PathAndQuery::from_static(
1084                "/zitadel.auth.v1.AuthService/VerifyMyAuthFactorU2F",
1085            );
1086            let mut req = request.into_request();
1087            req.extensions_mut()
1088                .insert(
1089                    GrpcMethod::new(
1090                        "zitadel.auth.v1.AuthService",
1091                        "VerifyMyAuthFactorU2F",
1092                    ),
1093                );
1094            self.inner.unary(req, path, codec).await
1095        }
1096        pub async fn remove_my_auth_factor_u2f(
1097            &mut self,
1098            request: impl tonic::IntoRequest<super::RemoveMyAuthFactorU2fRequest>,
1099        ) -> std::result::Result<
1100            tonic::Response<super::RemoveMyAuthFactorU2fResponse>,
1101            tonic::Status,
1102        > {
1103            self.inner
1104                .ready()
1105                .await
1106                .map_err(|e| {
1107                    tonic::Status::unknown(
1108                        format!("Service was not ready: {}", e.into()),
1109                    )
1110                })?;
1111            let codec = tonic::codec::ProstCodec::default();
1112            let path = http::uri::PathAndQuery::from_static(
1113                "/zitadel.auth.v1.AuthService/RemoveMyAuthFactorU2F",
1114            );
1115            let mut req = request.into_request();
1116            req.extensions_mut()
1117                .insert(
1118                    GrpcMethod::new(
1119                        "zitadel.auth.v1.AuthService",
1120                        "RemoveMyAuthFactorU2F",
1121                    ),
1122                );
1123            self.inner.unary(req, path, codec).await
1124        }
1125        pub async fn list_my_passwordless(
1126            &mut self,
1127            request: impl tonic::IntoRequest<super::ListMyPasswordlessRequest>,
1128        ) -> std::result::Result<
1129            tonic::Response<super::ListMyPasswordlessResponse>,
1130            tonic::Status,
1131        > {
1132            self.inner
1133                .ready()
1134                .await
1135                .map_err(|e| {
1136                    tonic::Status::unknown(
1137                        format!("Service was not ready: {}", e.into()),
1138                    )
1139                })?;
1140            let codec = tonic::codec::ProstCodec::default();
1141            let path = http::uri::PathAndQuery::from_static(
1142                "/zitadel.auth.v1.AuthService/ListMyPasswordless",
1143            );
1144            let mut req = request.into_request();
1145            req.extensions_mut()
1146                .insert(
1147                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyPasswordless"),
1148                );
1149            self.inner.unary(req, path, codec).await
1150        }
1151        pub async fn add_my_passwordless(
1152            &mut self,
1153            request: impl tonic::IntoRequest<super::AddMyPasswordlessRequest>,
1154        ) -> std::result::Result<
1155            tonic::Response<super::AddMyPasswordlessResponse>,
1156            tonic::Status,
1157        > {
1158            self.inner
1159                .ready()
1160                .await
1161                .map_err(|e| {
1162                    tonic::Status::unknown(
1163                        format!("Service was not ready: {}", e.into()),
1164                    )
1165                })?;
1166            let codec = tonic::codec::ProstCodec::default();
1167            let path = http::uri::PathAndQuery::from_static(
1168                "/zitadel.auth.v1.AuthService/AddMyPasswordless",
1169            );
1170            let mut req = request.into_request();
1171            req.extensions_mut()
1172                .insert(
1173                    GrpcMethod::new("zitadel.auth.v1.AuthService", "AddMyPasswordless"),
1174                );
1175            self.inner.unary(req, path, codec).await
1176        }
1177        pub async fn add_my_passwordless_link(
1178            &mut self,
1179            request: impl tonic::IntoRequest<super::AddMyPasswordlessLinkRequest>,
1180        ) -> std::result::Result<
1181            tonic::Response<super::AddMyPasswordlessLinkResponse>,
1182            tonic::Status,
1183        > {
1184            self.inner
1185                .ready()
1186                .await
1187                .map_err(|e| {
1188                    tonic::Status::unknown(
1189                        format!("Service was not ready: {}", e.into()),
1190                    )
1191                })?;
1192            let codec = tonic::codec::ProstCodec::default();
1193            let path = http::uri::PathAndQuery::from_static(
1194                "/zitadel.auth.v1.AuthService/AddMyPasswordlessLink",
1195            );
1196            let mut req = request.into_request();
1197            req.extensions_mut()
1198                .insert(
1199                    GrpcMethod::new(
1200                        "zitadel.auth.v1.AuthService",
1201                        "AddMyPasswordlessLink",
1202                    ),
1203                );
1204            self.inner.unary(req, path, codec).await
1205        }
1206        pub async fn send_my_passwordless_link(
1207            &mut self,
1208            request: impl tonic::IntoRequest<super::SendMyPasswordlessLinkRequest>,
1209        ) -> std::result::Result<
1210            tonic::Response<super::SendMyPasswordlessLinkResponse>,
1211            tonic::Status,
1212        > {
1213            self.inner
1214                .ready()
1215                .await
1216                .map_err(|e| {
1217                    tonic::Status::unknown(
1218                        format!("Service was not ready: {}", e.into()),
1219                    )
1220                })?;
1221            let codec = tonic::codec::ProstCodec::default();
1222            let path = http::uri::PathAndQuery::from_static(
1223                "/zitadel.auth.v1.AuthService/SendMyPasswordlessLink",
1224            );
1225            let mut req = request.into_request();
1226            req.extensions_mut()
1227                .insert(
1228                    GrpcMethod::new(
1229                        "zitadel.auth.v1.AuthService",
1230                        "SendMyPasswordlessLink",
1231                    ),
1232                );
1233            self.inner.unary(req, path, codec).await
1234        }
1235        pub async fn verify_my_passwordless(
1236            &mut self,
1237            request: impl tonic::IntoRequest<super::VerifyMyPasswordlessRequest>,
1238        ) -> std::result::Result<
1239            tonic::Response<super::VerifyMyPasswordlessResponse>,
1240            tonic::Status,
1241        > {
1242            self.inner
1243                .ready()
1244                .await
1245                .map_err(|e| {
1246                    tonic::Status::unknown(
1247                        format!("Service was not ready: {}", e.into()),
1248                    )
1249                })?;
1250            let codec = tonic::codec::ProstCodec::default();
1251            let path = http::uri::PathAndQuery::from_static(
1252                "/zitadel.auth.v1.AuthService/VerifyMyPasswordless",
1253            );
1254            let mut req = request.into_request();
1255            req.extensions_mut()
1256                .insert(
1257                    GrpcMethod::new(
1258                        "zitadel.auth.v1.AuthService",
1259                        "VerifyMyPasswordless",
1260                    ),
1261                );
1262            self.inner.unary(req, path, codec).await
1263        }
1264        pub async fn remove_my_passwordless(
1265            &mut self,
1266            request: impl tonic::IntoRequest<super::RemoveMyPasswordlessRequest>,
1267        ) -> std::result::Result<
1268            tonic::Response<super::RemoveMyPasswordlessResponse>,
1269            tonic::Status,
1270        > {
1271            self.inner
1272                .ready()
1273                .await
1274                .map_err(|e| {
1275                    tonic::Status::unknown(
1276                        format!("Service was not ready: {}", e.into()),
1277                    )
1278                })?;
1279            let codec = tonic::codec::ProstCodec::default();
1280            let path = http::uri::PathAndQuery::from_static(
1281                "/zitadel.auth.v1.AuthService/RemoveMyPasswordless",
1282            );
1283            let mut req = request.into_request();
1284            req.extensions_mut()
1285                .insert(
1286                    GrpcMethod::new(
1287                        "zitadel.auth.v1.AuthService",
1288                        "RemoveMyPasswordless",
1289                    ),
1290                );
1291            self.inner.unary(req, path, codec).await
1292        }
1293        pub async fn list_my_user_grants(
1294            &mut self,
1295            request: impl tonic::IntoRequest<super::ListMyUserGrantsRequest>,
1296        ) -> std::result::Result<
1297            tonic::Response<super::ListMyUserGrantsResponse>,
1298            tonic::Status,
1299        > {
1300            self.inner
1301                .ready()
1302                .await
1303                .map_err(|e| {
1304                    tonic::Status::unknown(
1305                        format!("Service was not ready: {}", e.into()),
1306                    )
1307                })?;
1308            let codec = tonic::codec::ProstCodec::default();
1309            let path = http::uri::PathAndQuery::from_static(
1310                "/zitadel.auth.v1.AuthService/ListMyUserGrants",
1311            );
1312            let mut req = request.into_request();
1313            req.extensions_mut()
1314                .insert(
1315                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyUserGrants"),
1316                );
1317            self.inner.unary(req, path, codec).await
1318        }
1319        pub async fn list_my_project_orgs(
1320            &mut self,
1321            request: impl tonic::IntoRequest<super::ListMyProjectOrgsRequest>,
1322        ) -> std::result::Result<
1323            tonic::Response<super::ListMyProjectOrgsResponse>,
1324            tonic::Status,
1325        > {
1326            self.inner
1327                .ready()
1328                .await
1329                .map_err(|e| {
1330                    tonic::Status::unknown(
1331                        format!("Service was not ready: {}", e.into()),
1332                    )
1333                })?;
1334            let codec = tonic::codec::ProstCodec::default();
1335            let path = http::uri::PathAndQuery::from_static(
1336                "/zitadel.auth.v1.AuthService/ListMyProjectOrgs",
1337            );
1338            let mut req = request.into_request();
1339            req.extensions_mut()
1340                .insert(
1341                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyProjectOrgs"),
1342                );
1343            self.inner.unary(req, path, codec).await
1344        }
1345        pub async fn list_my_zitadel_permissions(
1346            &mut self,
1347            request: impl tonic::IntoRequest<super::ListMyZitadelPermissionsRequest>,
1348        ) -> std::result::Result<
1349            tonic::Response<super::ListMyZitadelPermissionsResponse>,
1350            tonic::Status,
1351        > {
1352            self.inner
1353                .ready()
1354                .await
1355                .map_err(|e| {
1356                    tonic::Status::unknown(
1357                        format!("Service was not ready: {}", e.into()),
1358                    )
1359                })?;
1360            let codec = tonic::codec::ProstCodec::default();
1361            let path = http::uri::PathAndQuery::from_static(
1362                "/zitadel.auth.v1.AuthService/ListMyZitadelPermissions",
1363            );
1364            let mut req = request.into_request();
1365            req.extensions_mut()
1366                .insert(
1367                    GrpcMethod::new(
1368                        "zitadel.auth.v1.AuthService",
1369                        "ListMyZitadelPermissions",
1370                    ),
1371                );
1372            self.inner.unary(req, path, codec).await
1373        }
1374        pub async fn list_my_project_permissions(
1375            &mut self,
1376            request: impl tonic::IntoRequest<super::ListMyProjectPermissionsRequest>,
1377        ) -> std::result::Result<
1378            tonic::Response<super::ListMyProjectPermissionsResponse>,
1379            tonic::Status,
1380        > {
1381            self.inner
1382                .ready()
1383                .await
1384                .map_err(|e| {
1385                    tonic::Status::unknown(
1386                        format!("Service was not ready: {}", e.into()),
1387                    )
1388                })?;
1389            let codec = tonic::codec::ProstCodec::default();
1390            let path = http::uri::PathAndQuery::from_static(
1391                "/zitadel.auth.v1.AuthService/ListMyProjectPermissions",
1392            );
1393            let mut req = request.into_request();
1394            req.extensions_mut()
1395                .insert(
1396                    GrpcMethod::new(
1397                        "zitadel.auth.v1.AuthService",
1398                        "ListMyProjectPermissions",
1399                    ),
1400                );
1401            self.inner.unary(req, path, codec).await
1402        }
1403        pub async fn list_my_memberships(
1404            &mut self,
1405            request: impl tonic::IntoRequest<super::ListMyMembershipsRequest>,
1406        ) -> std::result::Result<
1407            tonic::Response<super::ListMyMembershipsResponse>,
1408            tonic::Status,
1409        > {
1410            self.inner
1411                .ready()
1412                .await
1413                .map_err(|e| {
1414                    tonic::Status::unknown(
1415                        format!("Service was not ready: {}", e.into()),
1416                    )
1417                })?;
1418            let codec = tonic::codec::ProstCodec::default();
1419            let path = http::uri::PathAndQuery::from_static(
1420                "/zitadel.auth.v1.AuthService/ListMyMemberships",
1421            );
1422            let mut req = request.into_request();
1423            req.extensions_mut()
1424                .insert(
1425                    GrpcMethod::new("zitadel.auth.v1.AuthService", "ListMyMemberships"),
1426                );
1427            self.inner.unary(req, path, codec).await
1428        }
1429        pub async fn get_my_label_policy(
1430            &mut self,
1431            request: impl tonic::IntoRequest<super::GetMyLabelPolicyRequest>,
1432        ) -> std::result::Result<
1433            tonic::Response<super::GetMyLabelPolicyResponse>,
1434            tonic::Status,
1435        > {
1436            self.inner
1437                .ready()
1438                .await
1439                .map_err(|e| {
1440                    tonic::Status::unknown(
1441                        format!("Service was not ready: {}", e.into()),
1442                    )
1443                })?;
1444            let codec = tonic::codec::ProstCodec::default();
1445            let path = http::uri::PathAndQuery::from_static(
1446                "/zitadel.auth.v1.AuthService/GetMyLabelPolicy",
1447            );
1448            let mut req = request.into_request();
1449            req.extensions_mut()
1450                .insert(
1451                    GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyLabelPolicy"),
1452                );
1453            self.inner.unary(req, path, codec).await
1454        }
1455        pub async fn get_my_privacy_policy(
1456            &mut self,
1457            request: impl tonic::IntoRequest<super::GetMyPrivacyPolicyRequest>,
1458        ) -> std::result::Result<
1459            tonic::Response<super::GetMyPrivacyPolicyResponse>,
1460            tonic::Status,
1461        > {
1462            self.inner
1463                .ready()
1464                .await
1465                .map_err(|e| {
1466                    tonic::Status::unknown(
1467                        format!("Service was not ready: {}", e.into()),
1468                    )
1469                })?;
1470            let codec = tonic::codec::ProstCodec::default();
1471            let path = http::uri::PathAndQuery::from_static(
1472                "/zitadel.auth.v1.AuthService/GetMyPrivacyPolicy",
1473            );
1474            let mut req = request.into_request();
1475            req.extensions_mut()
1476                .insert(
1477                    GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyPrivacyPolicy"),
1478                );
1479            self.inner.unary(req, path, codec).await
1480        }
1481        pub async fn get_my_login_policy(
1482            &mut self,
1483            request: impl tonic::IntoRequest<super::GetMyLoginPolicyRequest>,
1484        ) -> std::result::Result<
1485            tonic::Response<super::GetMyLoginPolicyResponse>,
1486            tonic::Status,
1487        > {
1488            self.inner
1489                .ready()
1490                .await
1491                .map_err(|e| {
1492                    tonic::Status::unknown(
1493                        format!("Service was not ready: {}", e.into()),
1494                    )
1495                })?;
1496            let codec = tonic::codec::ProstCodec::default();
1497            let path = http::uri::PathAndQuery::from_static(
1498                "/zitadel.auth.v1.AuthService/GetMyLoginPolicy",
1499            );
1500            let mut req = request.into_request();
1501            req.extensions_mut()
1502                .insert(
1503                    GrpcMethod::new("zitadel.auth.v1.AuthService", "GetMyLoginPolicy"),
1504                );
1505            self.inner.unary(req, path, codec).await
1506        }
1507    }
1508}
zitadel/api/generated/zitadel.auth.v1.tonic.rs

zitadel/api/generated/
zitadel.auth.v1.tonic.rs
