pub mod auth_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
#[derive(Debug, Clone)]
pub struct AuthServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl AuthServiceClient<tonic::transport::Channel> {
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> AuthServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_origin(inner: T, origin: Uri) -> Self {
let inner = tonic::client::Grpc::with_origin(inner, origin);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> AuthServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
>>::Error: Into<StdError> + Send + Sync,
{
AuthServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
pub async fn healthz(
&mut self,
request: impl tonic::IntoRequest<super::HealthzRequest>,
) -> Result<tonic::Response<super::HealthzResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/Healthz",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_supported_languages(
&mut self,
request: impl tonic::IntoRequest<super::GetSupportedLanguagesRequest>,
) -> Result<
tonic::Response<super::GetSupportedLanguagesResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetSupportedLanguages",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_user(
&mut self,
request: impl tonic::IntoRequest<super::GetMyUserRequest>,
) -> Result<tonic::Response<super::GetMyUserResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyUser",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_user(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyUserRequest>,
) -> Result<tonic::Response<super::RemoveMyUserResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyUser",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_user_changes(
&mut self,
request: impl tonic::IntoRequest<super::ListMyUserChangesRequest>,
) -> Result<tonic::Response<super::ListMyUserChangesResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyUserChanges",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_user_sessions(
&mut self,
request: impl tonic::IntoRequest<super::ListMyUserSessionsRequest>,
) -> Result<tonic::Response<super::ListMyUserSessionsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyUserSessions",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_metadata(
&mut self,
request: impl tonic::IntoRequest<super::ListMyMetadataRequest>,
) -> Result<tonic::Response<super::ListMyMetadataResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyMetadata",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_metadata(
&mut self,
request: impl tonic::IntoRequest<super::GetMyMetadataRequest>,
) -> Result<tonic::Response<super::GetMyMetadataResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyMetadata",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_refresh_tokens(
&mut self,
request: impl tonic::IntoRequest<super::ListMyRefreshTokensRequest>,
) -> Result<tonic::Response<super::ListMyRefreshTokensResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyRefreshTokens",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn revoke_my_refresh_token(
&mut self,
request: impl tonic::IntoRequest<super::RevokeMyRefreshTokenRequest>,
) -> Result<
tonic::Response<super::RevokeMyRefreshTokenResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RevokeMyRefreshToken",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn revoke_all_my_refresh_tokens(
&mut self,
request: impl tonic::IntoRequest<super::RevokeAllMyRefreshTokensRequest>,
) -> Result<
tonic::Response<super::RevokeAllMyRefreshTokensResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RevokeAllMyRefreshTokens",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_my_user_name(
&mut self,
request: impl tonic::IntoRequest<super::UpdateMyUserNameRequest>,
) -> Result<tonic::Response<super::UpdateMyUserNameResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/UpdateMyUserName",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_password_complexity_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetMyPasswordComplexityPolicyRequest>,
) -> Result<
tonic::Response<super::GetMyPasswordComplexityPolicyResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyPasswordComplexityPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_my_password(
&mut self,
request: impl tonic::IntoRequest<super::UpdateMyPasswordRequest>,
) -> Result<tonic::Response<super::UpdateMyPasswordResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/UpdateMyPassword",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_profile(
&mut self,
request: impl tonic::IntoRequest<super::GetMyProfileRequest>,
) -> Result<tonic::Response<super::GetMyProfileResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_my_profile(
&mut self,
request: impl tonic::IntoRequest<super::UpdateMyProfileRequest>,
) -> Result<tonic::Response<super::UpdateMyProfileResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/UpdateMyProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_email(
&mut self,
request: impl tonic::IntoRequest<super::GetMyEmailRequest>,
) -> Result<tonic::Response<super::GetMyEmailResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyEmail",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_my_email(
&mut self,
request: impl tonic::IntoRequest<super::SetMyEmailRequest>,
) -> Result<tonic::Response<super::SetMyEmailResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/SetMyEmail",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn verify_my_email(
&mut self,
request: impl tonic::IntoRequest<super::VerifyMyEmailRequest>,
) -> Result<tonic::Response<super::VerifyMyEmailResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/VerifyMyEmail",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn resend_my_email_verification(
&mut self,
request: impl tonic::IntoRequest<super::ResendMyEmailVerificationRequest>,
) -> Result<
tonic::Response<super::ResendMyEmailVerificationResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ResendMyEmailVerification",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_phone(
&mut self,
request: impl tonic::IntoRequest<super::GetMyPhoneRequest>,
) -> Result<tonic::Response<super::GetMyPhoneResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyPhone",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_my_phone(
&mut self,
request: impl tonic::IntoRequest<super::SetMyPhoneRequest>,
) -> Result<tonic::Response<super::SetMyPhoneResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/SetMyPhone",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn verify_my_phone(
&mut self,
request: impl tonic::IntoRequest<super::VerifyMyPhoneRequest>,
) -> Result<tonic::Response<super::VerifyMyPhoneResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/VerifyMyPhone",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn resend_my_phone_verification(
&mut self,
request: impl tonic::IntoRequest<super::ResendMyPhoneVerificationRequest>,
) -> Result<
tonic::Response<super::ResendMyPhoneVerificationResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ResendMyPhoneVerification",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_phone(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyPhoneRequest>,
) -> Result<tonic::Response<super::RemoveMyPhoneResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyPhone",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_avatar(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyAvatarRequest>,
) -> Result<tonic::Response<super::RemoveMyAvatarResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyAvatar",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_linked_id_ps(
&mut self,
request: impl tonic::IntoRequest<super::ListMyLinkedIdPsRequest>,
) -> Result<tonic::Response<super::ListMyLinkedIdPsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyLinkedIDPs",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_linked_idp(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyLinkedIdpRequest>,
) -> Result<tonic::Response<super::RemoveMyLinkedIdpResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyLinkedIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_auth_factors(
&mut self,
request: impl tonic::IntoRequest<super::ListMyAuthFactorsRequest>,
) -> Result<tonic::Response<super::ListMyAuthFactorsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyAuthFactors",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_my_auth_factor_otp(
&mut self,
request: impl tonic::IntoRequest<super::AddMyAuthFactorOtpRequest>,
) -> Result<tonic::Response<super::AddMyAuthFactorOtpResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/AddMyAuthFactorOTP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn verify_my_auth_factor_otp(
&mut self,
request: impl tonic::IntoRequest<super::VerifyMyAuthFactorOtpRequest>,
) -> Result<
tonic::Response<super::VerifyMyAuthFactorOtpResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/VerifyMyAuthFactorOTP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_auth_factor_otp(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyAuthFactorOtpRequest>,
) -> Result<
tonic::Response<super::RemoveMyAuthFactorOtpResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyAuthFactorOTP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_my_auth_factor_u2f(
&mut self,
request: impl tonic::IntoRequest<super::AddMyAuthFactorU2fRequest>,
) -> Result<tonic::Response<super::AddMyAuthFactorU2fResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/AddMyAuthFactorU2F",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn verify_my_auth_factor_u2f(
&mut self,
request: impl tonic::IntoRequest<super::VerifyMyAuthFactorU2fRequest>,
) -> Result<
tonic::Response<super::VerifyMyAuthFactorU2fResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/VerifyMyAuthFactorU2F",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_auth_factor_u2f(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyAuthFactorU2fRequest>,
) -> Result<
tonic::Response<super::RemoveMyAuthFactorU2fResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyAuthFactorU2F",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_passwordless(
&mut self,
request: impl tonic::IntoRequest<super::ListMyPasswordlessRequest>,
) -> Result<tonic::Response<super::ListMyPasswordlessResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyPasswordless",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_my_passwordless(
&mut self,
request: impl tonic::IntoRequest<super::AddMyPasswordlessRequest>,
) -> Result<tonic::Response<super::AddMyPasswordlessResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/AddMyPasswordless",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_my_passwordless_link(
&mut self,
request: impl tonic::IntoRequest<super::AddMyPasswordlessLinkRequest>,
) -> Result<
tonic::Response<super::AddMyPasswordlessLinkResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/AddMyPasswordlessLink",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn send_my_passwordless_link(
&mut self,
request: impl tonic::IntoRequest<super::SendMyPasswordlessLinkRequest>,
) -> Result<
tonic::Response<super::SendMyPasswordlessLinkResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/SendMyPasswordlessLink",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn verify_my_passwordless(
&mut self,
request: impl tonic::IntoRequest<super::VerifyMyPasswordlessRequest>,
) -> Result<
tonic::Response<super::VerifyMyPasswordlessResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/VerifyMyPasswordless",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_my_passwordless(
&mut self,
request: impl tonic::IntoRequest<super::RemoveMyPasswordlessRequest>,
) -> Result<
tonic::Response<super::RemoveMyPasswordlessResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/RemoveMyPasswordless",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_user_grants(
&mut self,
request: impl tonic::IntoRequest<super::ListMyUserGrantsRequest>,
) -> Result<tonic::Response<super::ListMyUserGrantsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyUserGrants",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_project_orgs(
&mut self,
request: impl tonic::IntoRequest<super::ListMyProjectOrgsRequest>,
) -> Result<tonic::Response<super::ListMyProjectOrgsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyProjectOrgs",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_zitadel_permissions(
&mut self,
request: impl tonic::IntoRequest<super::ListMyZitadelPermissionsRequest>,
) -> Result<
tonic::Response<super::ListMyZitadelPermissionsResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyZitadelPermissions",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_project_permissions(
&mut self,
request: impl tonic::IntoRequest<super::ListMyProjectPermissionsRequest>,
) -> Result<
tonic::Response<super::ListMyProjectPermissionsResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyProjectPermissions",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_my_memberships(
&mut self,
request: impl tonic::IntoRequest<super::ListMyMembershipsRequest>,
) -> Result<tonic::Response<super::ListMyMembershipsResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/ListMyMemberships",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_label_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetMyLabelPolicyRequest>,
) -> Result<tonic::Response<super::GetMyLabelPolicyResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyLabelPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_privacy_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetMyPrivacyPolicyRequest>,
) -> Result<tonic::Response<super::GetMyPrivacyPolicyResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyPrivacyPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetMyLoginPolicyRequest>,
) -> Result<tonic::Response<super::GetMyLoginPolicyResponse>, tonic::Status> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/zitadel.auth.v1.AuthService/GetMyLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}