pub mod admin_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 AdminServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl AdminServiceClient<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> AdminServiceClient<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,
) -> AdminServiceClient<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,
{
AdminServiceClient::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.admin.v1.AdminService/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.admin.v1.AdminService/GetSupportedLanguages",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_language(
&mut self,
request: impl tonic::IntoRequest<super::SetDefaultLanguageRequest>,
) -> Result<tonic::Response<super::SetDefaultLanguageResponse>, 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.admin.v1.AdminService/SetDefaultLanguage",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_language(
&mut self,
request: impl tonic::IntoRequest<super::GetDefaultLanguageRequest>,
) -> Result<tonic::Response<super::GetDefaultLanguageResponse>, 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.admin.v1.AdminService/GetDefaultLanguage",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_my_instance(
&mut self,
request: impl tonic::IntoRequest<super::GetMyInstanceRequest>,
) -> Result<tonic::Response<super::GetMyInstanceResponse>, 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.admin.v1.AdminService/GetMyInstance",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_instance_domains(
&mut self,
request: impl tonic::IntoRequest<super::ListInstanceDomainsRequest>,
) -> Result<tonic::Response<super::ListInstanceDomainsResponse>, 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.admin.v1.AdminService/ListInstanceDomains",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_secret_generators(
&mut self,
request: impl tonic::IntoRequest<super::ListSecretGeneratorsRequest>,
) -> Result<
tonic::Response<super::ListSecretGeneratorsResponse>,
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.admin.v1.AdminService/ListSecretGenerators",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_secret_generator(
&mut self,
request: impl tonic::IntoRequest<super::GetSecretGeneratorRequest>,
) -> Result<tonic::Response<super::GetSecretGeneratorResponse>, 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.admin.v1.AdminService/GetSecretGenerator",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_secret_generator(
&mut self,
request: impl tonic::IntoRequest<super::UpdateSecretGeneratorRequest>,
) -> Result<
tonic::Response<super::UpdateSecretGeneratorResponse>,
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.admin.v1.AdminService/UpdateSecretGenerator",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_smtp_config(
&mut self,
request: impl tonic::IntoRequest<super::GetSmtpConfigRequest>,
) -> Result<tonic::Response<super::GetSmtpConfigResponse>, 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.admin.v1.AdminService/GetSMTPConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_smtp_config(
&mut self,
request: impl tonic::IntoRequest<super::AddSmtpConfigRequest>,
) -> Result<tonic::Response<super::AddSmtpConfigResponse>, 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.admin.v1.AdminService/AddSMTPConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_smtp_config(
&mut self,
request: impl tonic::IntoRequest<super::UpdateSmtpConfigRequest>,
) -> Result<tonic::Response<super::UpdateSmtpConfigResponse>, 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.admin.v1.AdminService/UpdateSMTPConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_smtp_config_password(
&mut self,
request: impl tonic::IntoRequest<super::UpdateSmtpConfigPasswordRequest>,
) -> Result<
tonic::Response<super::UpdateSmtpConfigPasswordResponse>,
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.admin.v1.AdminService/UpdateSMTPConfigPassword",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_smtp_config(
&mut self,
request: impl tonic::IntoRequest<super::RemoveSmtpConfigRequest>,
) -> Result<tonic::Response<super::RemoveSmtpConfigResponse>, 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.admin.v1.AdminService/RemoveSMTPConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_sms_providers(
&mut self,
request: impl tonic::IntoRequest<super::ListSmsProvidersRequest>,
) -> Result<tonic::Response<super::ListSmsProvidersResponse>, 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.admin.v1.AdminService/ListSMSProviders",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_sms_provider(
&mut self,
request: impl tonic::IntoRequest<super::GetSmsProviderRequest>,
) -> Result<tonic::Response<super::GetSmsProviderResponse>, 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.admin.v1.AdminService/GetSMSProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_sms_provider_twilio(
&mut self,
request: impl tonic::IntoRequest<super::AddSmsProviderTwilioRequest>,
) -> Result<
tonic::Response<super::AddSmsProviderTwilioResponse>,
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.admin.v1.AdminService/AddSMSProviderTwilio",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_sms_provider_twilio(
&mut self,
request: impl tonic::IntoRequest<super::UpdateSmsProviderTwilioRequest>,
) -> Result<
tonic::Response<super::UpdateSmsProviderTwilioResponse>,
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.admin.v1.AdminService/UpdateSMSProviderTwilio",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_sms_provider_twilio_token(
&mut self,
request: impl tonic::IntoRequest<super::UpdateSmsProviderTwilioTokenRequest>,
) -> Result<
tonic::Response<super::UpdateSmsProviderTwilioTokenResponse>,
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.admin.v1.AdminService/UpdateSMSProviderTwilioToken",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn activate_sms_provider(
&mut self,
request: impl tonic::IntoRequest<super::ActivateSmsProviderRequest>,
) -> Result<tonic::Response<super::ActivateSmsProviderResponse>, 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.admin.v1.AdminService/ActivateSMSProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn deactivate_sms_provider(
&mut self,
request: impl tonic::IntoRequest<super::DeactivateSmsProviderRequest>,
) -> Result<
tonic::Response<super::DeactivateSmsProviderResponse>,
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.admin.v1.AdminService/DeactivateSMSProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_sms_provider(
&mut self,
request: impl tonic::IntoRequest<super::RemoveSmsProviderRequest>,
) -> Result<tonic::Response<super::RemoveSmsProviderResponse>, 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.admin.v1.AdminService/RemoveSMSProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_oidc_settings(
&mut self,
request: impl tonic::IntoRequest<super::GetOidcSettingsRequest>,
) -> Result<tonic::Response<super::GetOidcSettingsResponse>, 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.admin.v1.AdminService/GetOIDCSettings",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_oidc_settings(
&mut self,
request: impl tonic::IntoRequest<super::AddOidcSettingsRequest>,
) -> Result<tonic::Response<super::AddOidcSettingsResponse>, 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.admin.v1.AdminService/AddOIDCSettings",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_oidc_settings(
&mut self,
request: impl tonic::IntoRequest<super::UpdateOidcSettingsRequest>,
) -> Result<tonic::Response<super::UpdateOidcSettingsResponse>, 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.admin.v1.AdminService/UpdateOIDCSettings",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_file_system_notification_provider(
&mut self,
request: impl tonic::IntoRequest<
super::GetFileSystemNotificationProviderRequest,
>,
) -> Result<
tonic::Response<super::GetFileSystemNotificationProviderResponse>,
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.admin.v1.AdminService/GetFileSystemNotificationProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_log_notification_provider(
&mut self,
request: impl tonic::IntoRequest<super::GetLogNotificationProviderRequest>,
) -> Result<
tonic::Response<super::GetLogNotificationProviderResponse>,
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.admin.v1.AdminService/GetLogNotificationProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_security_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetSecurityPolicyRequest>,
) -> Result<tonic::Response<super::GetSecurityPolicyResponse>, 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.admin.v1.AdminService/GetSecurityPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_security_policy(
&mut self,
request: impl tonic::IntoRequest<super::SetSecurityPolicyRequest>,
) -> Result<tonic::Response<super::SetSecurityPolicyResponse>, 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.admin.v1.AdminService/SetSecurityPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_org_by_id(
&mut self,
request: impl tonic::IntoRequest<super::GetOrgByIdRequest>,
) -> Result<tonic::Response<super::GetOrgByIdResponse>, 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.admin.v1.AdminService/GetOrgByID",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn is_org_unique(
&mut self,
request: impl tonic::IntoRequest<super::IsOrgUniqueRequest>,
) -> Result<tonic::Response<super::IsOrgUniqueResponse>, 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.admin.v1.AdminService/IsOrgUnique",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_org(
&mut self,
request: impl tonic::IntoRequest<super::SetDefaultOrgRequest>,
) -> Result<tonic::Response<super::SetDefaultOrgResponse>, 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.admin.v1.AdminService/SetDefaultOrg",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_org(
&mut self,
request: impl tonic::IntoRequest<super::GetDefaultOrgRequest>,
) -> Result<tonic::Response<super::GetDefaultOrgResponse>, 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.admin.v1.AdminService/GetDefaultOrg",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_orgs(
&mut self,
request: impl tonic::IntoRequest<super::ListOrgsRequest>,
) -> Result<tonic::Response<super::ListOrgsResponse>, 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.admin.v1.AdminService/ListOrgs",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_up_org(
&mut self,
request: impl tonic::IntoRequest<super::SetUpOrgRequest>,
) -> Result<tonic::Response<super::SetUpOrgResponse>, 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.admin.v1.AdminService/SetUpOrg",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_org(
&mut self,
request: impl tonic::IntoRequest<super::RemoveOrgRequest>,
) -> Result<tonic::Response<super::RemoveOrgResponse>, 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.admin.v1.AdminService/RemoveOrg",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_idp_by_id(
&mut self,
request: impl tonic::IntoRequest<super::GetIdpByIdRequest>,
) -> Result<tonic::Response<super::GetIdpByIdResponse>, 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.admin.v1.AdminService/GetIDPByID",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_id_ps(
&mut self,
request: impl tonic::IntoRequest<super::ListIdPsRequest>,
) -> Result<tonic::Response<super::ListIdPsResponse>, 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.admin.v1.AdminService/ListIDPs",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_oidcidp(
&mut self,
request: impl tonic::IntoRequest<super::AddOidcidpRequest>,
) -> Result<tonic::Response<super::AddOidcidpResponse>, 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.admin.v1.AdminService/AddOIDCIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_jwtidp(
&mut self,
request: impl tonic::IntoRequest<super::AddJwtidpRequest>,
) -> Result<tonic::Response<super::AddJwtidpResponse>, 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.admin.v1.AdminService/AddJWTIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_idp(
&mut self,
request: impl tonic::IntoRequest<super::UpdateIdpRequest>,
) -> Result<tonic::Response<super::UpdateIdpResponse>, 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.admin.v1.AdminService/UpdateIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn deactivate_idp(
&mut self,
request: impl tonic::IntoRequest<super::DeactivateIdpRequest>,
) -> Result<tonic::Response<super::DeactivateIdpResponse>, 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.admin.v1.AdminService/DeactivateIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reactivate_idp(
&mut self,
request: impl tonic::IntoRequest<super::ReactivateIdpRequest>,
) -> Result<tonic::Response<super::ReactivateIdpResponse>, 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.admin.v1.AdminService/ReactivateIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_idp(
&mut self,
request: impl tonic::IntoRequest<super::RemoveIdpRequest>,
) -> Result<tonic::Response<super::RemoveIdpResponse>, 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.admin.v1.AdminService/RemoveIDP",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_idpoidc_config(
&mut self,
request: impl tonic::IntoRequest<super::UpdateIdpoidcConfigRequest>,
) -> Result<tonic::Response<super::UpdateIdpoidcConfigResponse>, 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.admin.v1.AdminService/UpdateIDPOIDCConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_idpjwt_config(
&mut self,
request: impl tonic::IntoRequest<super::UpdateIdpjwtConfigRequest>,
) -> Result<tonic::Response<super::UpdateIdpjwtConfigResponse>, 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.admin.v1.AdminService/UpdateIDPJWTConfig",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_providers(
&mut self,
request: impl tonic::IntoRequest<super::ListProvidersRequest>,
) -> Result<tonic::Response<super::ListProvidersResponse>, 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.admin.v1.AdminService/ListProviders",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_provider_by_id(
&mut self,
request: impl tonic::IntoRequest<super::GetProviderByIdRequest>,
) -> Result<tonic::Response<super::GetProviderByIdResponse>, 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.admin.v1.AdminService/GetProviderByID",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_generic_o_auth_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGenericOAuthProviderRequest>,
) -> Result<
tonic::Response<super::AddGenericOAuthProviderResponse>,
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.admin.v1.AdminService/AddGenericOAuthProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_generic_o_auth_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateGenericOAuthProviderRequest>,
) -> Result<
tonic::Response<super::UpdateGenericOAuthProviderResponse>,
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.admin.v1.AdminService/UpdateGenericOAuthProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_generic_oidc_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGenericOidcProviderRequest>,
) -> Result<
tonic::Response<super::AddGenericOidcProviderResponse>,
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.admin.v1.AdminService/AddGenericOIDCProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_generic_oidc_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateGenericOidcProviderRequest>,
) -> Result<
tonic::Response<super::UpdateGenericOidcProviderResponse>,
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.admin.v1.AdminService/UpdateGenericOIDCProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn migrate_generic_oidc_provider(
&mut self,
request: impl tonic::IntoRequest<super::MigrateGenericOidcProviderRequest>,
) -> Result<
tonic::Response<super::MigrateGenericOidcProviderResponse>,
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.admin.v1.AdminService/MigrateGenericOIDCProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_jwt_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddJwtProviderRequest>,
) -> Result<tonic::Response<super::AddJwtProviderResponse>, 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.admin.v1.AdminService/AddJWTProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_jwt_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateJwtProviderRequest>,
) -> Result<tonic::Response<super::UpdateJwtProviderResponse>, 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.admin.v1.AdminService/UpdateJWTProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_azure_ad_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddAzureAdProviderRequest>,
) -> Result<tonic::Response<super::AddAzureAdProviderResponse>, 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.admin.v1.AdminService/AddAzureADProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_azure_ad_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateAzureAdProviderRequest>,
) -> Result<
tonic::Response<super::UpdateAzureAdProviderResponse>,
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.admin.v1.AdminService/UpdateAzureADProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_git_hub_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGitHubProviderRequest>,
) -> Result<tonic::Response<super::AddGitHubProviderResponse>, 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.admin.v1.AdminService/AddGitHubProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_git_hub_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateGitHubProviderRequest>,
) -> Result<
tonic::Response<super::UpdateGitHubProviderResponse>,
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.admin.v1.AdminService/UpdateGitHubProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_git_hub_enterprise_server_provider(
&mut self,
request: impl tonic::IntoRequest<
super::AddGitHubEnterpriseServerProviderRequest,
>,
) -> Result<
tonic::Response<super::AddGitHubEnterpriseServerProviderResponse>,
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.admin.v1.AdminService/AddGitHubEnterpriseServerProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_git_hub_enterprise_server_provider(
&mut self,
request: impl tonic::IntoRequest<
super::UpdateGitHubEnterpriseServerProviderRequest,
>,
) -> Result<
tonic::Response<super::UpdateGitHubEnterpriseServerProviderResponse>,
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.admin.v1.AdminService/UpdateGitHubEnterpriseServerProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_git_lab_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGitLabProviderRequest>,
) -> Result<tonic::Response<super::AddGitLabProviderResponse>, 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.admin.v1.AdminService/AddGitLabProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_git_lab_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateGitLabProviderRequest>,
) -> Result<
tonic::Response<super::UpdateGitLabProviderResponse>,
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.admin.v1.AdminService/UpdateGitLabProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_git_lab_self_hosted_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGitLabSelfHostedProviderRequest>,
) -> Result<
tonic::Response<super::AddGitLabSelfHostedProviderResponse>,
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.admin.v1.AdminService/AddGitLabSelfHostedProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_git_lab_self_hosted_provider(
&mut self,
request: impl tonic::IntoRequest<
super::UpdateGitLabSelfHostedProviderRequest,
>,
) -> Result<
tonic::Response<super::UpdateGitLabSelfHostedProviderResponse>,
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.admin.v1.AdminService/UpdateGitLabSelfHostedProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_google_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddGoogleProviderRequest>,
) -> Result<tonic::Response<super::AddGoogleProviderResponse>, 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.admin.v1.AdminService/AddGoogleProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_google_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateGoogleProviderRequest>,
) -> Result<
tonic::Response<super::UpdateGoogleProviderResponse>,
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.admin.v1.AdminService/UpdateGoogleProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_ldap_provider(
&mut self,
request: impl tonic::IntoRequest<super::AddLdapProviderRequest>,
) -> Result<tonic::Response<super::AddLdapProviderResponse>, 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.admin.v1.AdminService/AddLDAPProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_ldap_provider(
&mut self,
request: impl tonic::IntoRequest<super::UpdateLdapProviderRequest>,
) -> Result<tonic::Response<super::UpdateLdapProviderResponse>, 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.admin.v1.AdminService/UpdateLDAPProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn delete_provider(
&mut self,
request: impl tonic::IntoRequest<super::DeleteProviderRequest>,
) -> Result<tonic::Response<super::DeleteProviderResponse>, 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.admin.v1.AdminService/DeleteProvider",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_org_iam_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetOrgIamPolicyRequest>,
) -> Result<tonic::Response<super::GetOrgIamPolicyResponse>, 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.admin.v1.AdminService/GetOrgIAMPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_org_iam_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateOrgIamPolicyRequest>,
) -> Result<tonic::Response<super::UpdateOrgIamPolicyResponse>, 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.admin.v1.AdminService/UpdateOrgIAMPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_org_iam_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetCustomOrgIamPolicyRequest>,
) -> Result<
tonic::Response<super::GetCustomOrgIamPolicyResponse>,
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.admin.v1.AdminService/GetCustomOrgIAMPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_custom_org_iam_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddCustomOrgIamPolicyRequest>,
) -> Result<
tonic::Response<super::AddCustomOrgIamPolicyResponse>,
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.admin.v1.AdminService/AddCustomOrgIAMPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_custom_org_iam_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateCustomOrgIamPolicyRequest>,
) -> Result<
tonic::Response<super::UpdateCustomOrgIamPolicyResponse>,
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.admin.v1.AdminService/UpdateCustomOrgIAMPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_org_iam_policy_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomOrgIamPolicyToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomOrgIamPolicyToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomOrgIAMPolicyToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_domain_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetDomainPolicyRequest>,
) -> Result<tonic::Response<super::GetDomainPolicyResponse>, 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.admin.v1.AdminService/GetDomainPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_domain_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateDomainPolicyRequest>,
) -> Result<tonic::Response<super::UpdateDomainPolicyResponse>, 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.admin.v1.AdminService/UpdateDomainPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_domain_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetCustomDomainPolicyRequest>,
) -> Result<
tonic::Response<super::GetCustomDomainPolicyResponse>,
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.admin.v1.AdminService/GetCustomDomainPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_custom_domain_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddCustomDomainPolicyRequest>,
) -> Result<
tonic::Response<super::AddCustomDomainPolicyResponse>,
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.admin.v1.AdminService/AddCustomDomainPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_custom_domain_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateCustomDomainPolicyRequest>,
) -> Result<
tonic::Response<super::UpdateCustomDomainPolicyResponse>,
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.admin.v1.AdminService/UpdateCustomDomainPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_domain_policy_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomDomainPolicyToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomDomainPolicyToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomDomainPolicyToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_label_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetLabelPolicyRequest>,
) -> Result<tonic::Response<super::GetLabelPolicyResponse>, 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.admin.v1.AdminService/GetLabelPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_preview_label_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetPreviewLabelPolicyRequest>,
) -> Result<
tonic::Response<super::GetPreviewLabelPolicyResponse>,
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.admin.v1.AdminService/GetPreviewLabelPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_label_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateLabelPolicyRequest>,
) -> Result<tonic::Response<super::UpdateLabelPolicyResponse>, 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.admin.v1.AdminService/UpdateLabelPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn activate_label_policy(
&mut self,
request: impl tonic::IntoRequest<super::ActivateLabelPolicyRequest>,
) -> Result<tonic::Response<super::ActivateLabelPolicyResponse>, 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.admin.v1.AdminService/ActivateLabelPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_label_policy_logo(
&mut self,
request: impl tonic::IntoRequest<super::RemoveLabelPolicyLogoRequest>,
) -> Result<
tonic::Response<super::RemoveLabelPolicyLogoResponse>,
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.admin.v1.AdminService/RemoveLabelPolicyLogo",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_label_policy_logo_dark(
&mut self,
request: impl tonic::IntoRequest<super::RemoveLabelPolicyLogoDarkRequest>,
) -> Result<
tonic::Response<super::RemoveLabelPolicyLogoDarkResponse>,
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.admin.v1.AdminService/RemoveLabelPolicyLogoDark",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_label_policy_icon(
&mut self,
request: impl tonic::IntoRequest<super::RemoveLabelPolicyIconRequest>,
) -> Result<
tonic::Response<super::RemoveLabelPolicyIconResponse>,
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.admin.v1.AdminService/RemoveLabelPolicyIcon",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_label_policy_icon_dark(
&mut self,
request: impl tonic::IntoRequest<super::RemoveLabelPolicyIconDarkRequest>,
) -> Result<
tonic::Response<super::RemoveLabelPolicyIconDarkResponse>,
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.admin.v1.AdminService/RemoveLabelPolicyIconDark",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_label_policy_font(
&mut self,
request: impl tonic::IntoRequest<super::RemoveLabelPolicyFontRequest>,
) -> Result<
tonic::Response<super::RemoveLabelPolicyFontResponse>,
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.admin.v1.AdminService/RemoveLabelPolicyFont",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetLoginPolicyRequest>,
) -> Result<tonic::Response<super::GetLoginPolicyResponse>, 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.admin.v1.AdminService/GetLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateLoginPolicyRequest>,
) -> Result<tonic::Response<super::UpdateLoginPolicyResponse>, 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.admin.v1.AdminService/UpdateLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_login_policy_id_ps(
&mut self,
request: impl tonic::IntoRequest<super::ListLoginPolicyIdPsRequest>,
) -> Result<tonic::Response<super::ListLoginPolicyIdPsResponse>, 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.admin.v1.AdminService/ListLoginPolicyIDPs",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_idp_to_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddIdpToLoginPolicyRequest>,
) -> Result<tonic::Response<super::AddIdpToLoginPolicyResponse>, 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.admin.v1.AdminService/AddIDPToLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_idp_from_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::RemoveIdpFromLoginPolicyRequest>,
) -> Result<
tonic::Response<super::RemoveIdpFromLoginPolicyResponse>,
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.admin.v1.AdminService/RemoveIDPFromLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_login_policy_second_factors(
&mut self,
request: impl tonic::IntoRequest<super::ListLoginPolicySecondFactorsRequest>,
) -> Result<
tonic::Response<super::ListLoginPolicySecondFactorsResponse>,
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.admin.v1.AdminService/ListLoginPolicySecondFactors",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_second_factor_to_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddSecondFactorToLoginPolicyRequest>,
) -> Result<
tonic::Response<super::AddSecondFactorToLoginPolicyResponse>,
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.admin.v1.AdminService/AddSecondFactorToLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_second_factor_from_login_policy(
&mut self,
request: impl tonic::IntoRequest<
super::RemoveSecondFactorFromLoginPolicyRequest,
>,
) -> Result<
tonic::Response<super::RemoveSecondFactorFromLoginPolicyResponse>,
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.admin.v1.AdminService/RemoveSecondFactorFromLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_login_policy_multi_factors(
&mut self,
request: impl tonic::IntoRequest<super::ListLoginPolicyMultiFactorsRequest>,
) -> Result<
tonic::Response<super::ListLoginPolicyMultiFactorsResponse>,
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.admin.v1.AdminService/ListLoginPolicyMultiFactors",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_multi_factor_to_login_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddMultiFactorToLoginPolicyRequest>,
) -> Result<
tonic::Response<super::AddMultiFactorToLoginPolicyResponse>,
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.admin.v1.AdminService/AddMultiFactorToLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_multi_factor_from_login_policy(
&mut self,
request: impl tonic::IntoRequest<
super::RemoveMultiFactorFromLoginPolicyRequest,
>,
) -> Result<
tonic::Response<super::RemoveMultiFactorFromLoginPolicyResponse>,
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.admin.v1.AdminService/RemoveMultiFactorFromLoginPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_password_complexity_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetPasswordComplexityPolicyRequest>,
) -> Result<
tonic::Response<super::GetPasswordComplexityPolicyResponse>,
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.admin.v1.AdminService/GetPasswordComplexityPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_password_complexity_policy(
&mut self,
request: impl tonic::IntoRequest<
super::UpdatePasswordComplexityPolicyRequest,
>,
) -> Result<
tonic::Response<super::UpdatePasswordComplexityPolicyResponse>,
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.admin.v1.AdminService/UpdatePasswordComplexityPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_password_age_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetPasswordAgePolicyRequest>,
) -> Result<
tonic::Response<super::GetPasswordAgePolicyResponse>,
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.admin.v1.AdminService/GetPasswordAgePolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_password_age_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdatePasswordAgePolicyRequest>,
) -> Result<
tonic::Response<super::UpdatePasswordAgePolicyResponse>,
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.admin.v1.AdminService/UpdatePasswordAgePolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_lockout_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetLockoutPolicyRequest>,
) -> Result<tonic::Response<super::GetLockoutPolicyResponse>, 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.admin.v1.AdminService/GetLockoutPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_lockout_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateLockoutPolicyRequest>,
) -> Result<tonic::Response<super::UpdateLockoutPolicyResponse>, 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.admin.v1.AdminService/UpdateLockoutPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_privacy_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetPrivacyPolicyRequest>,
) -> Result<tonic::Response<super::GetPrivacyPolicyResponse>, 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.admin.v1.AdminService/GetPrivacyPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_privacy_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdatePrivacyPolicyRequest>,
) -> Result<tonic::Response<super::UpdatePrivacyPolicyResponse>, 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.admin.v1.AdminService/UpdatePrivacyPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_notification_policy(
&mut self,
request: impl tonic::IntoRequest<super::AddNotificationPolicyRequest>,
) -> Result<
tonic::Response<super::AddNotificationPolicyResponse>,
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.admin.v1.AdminService/AddNotificationPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_notification_policy(
&mut self,
request: impl tonic::IntoRequest<super::GetNotificationPolicyRequest>,
) -> Result<
tonic::Response<super::GetNotificationPolicyResponse>,
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.admin.v1.AdminService/GetNotificationPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_notification_policy(
&mut self,
request: impl tonic::IntoRequest<super::UpdateNotificationPolicyRequest>,
) -> Result<
tonic::Response<super::UpdateNotificationPolicyResponse>,
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.admin.v1.AdminService/UpdateNotificationPolicy",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_init_message_text(
&mut self,
request: impl tonic::IntoRequest<super::GetDefaultInitMessageTextRequest>,
) -> Result<
tonic::Response<super::GetDefaultInitMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultInitMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_init_message_text(
&mut self,
request: impl tonic::IntoRequest<super::GetCustomInitMessageTextRequest>,
) -> Result<
tonic::Response<super::GetCustomInitMessageTextResponse>,
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.admin.v1.AdminService/GetCustomInitMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_init_message_text(
&mut self,
request: impl tonic::IntoRequest<super::SetDefaultInitMessageTextRequest>,
) -> Result<
tonic::Response<super::SetDefaultInitMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultInitMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_init_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomInitMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomInitMessageTextToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomInitMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_password_reset_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultPasswordResetMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetDefaultPasswordResetMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultPasswordResetMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_password_reset_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomPasswordResetMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomPasswordResetMessageTextResponse>,
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.admin.v1.AdminService/GetCustomPasswordResetMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_password_reset_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultPasswordResetMessageTextRequest,
>,
) -> Result<
tonic::Response<super::SetDefaultPasswordResetMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultPasswordResetMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_password_reset_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomPasswordResetMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomPasswordResetMessageTextToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomPasswordResetMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_verify_email_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultVerifyEmailMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetDefaultVerifyEmailMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultVerifyEmailMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_verify_email_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomVerifyEmailMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomVerifyEmailMessageTextResponse>,
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.admin.v1.AdminService/GetCustomVerifyEmailMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_verify_email_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultVerifyEmailMessageTextRequest,
>,
) -> Result<
tonic::Response<super::SetDefaultVerifyEmailMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultVerifyEmailMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_verify_email_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomVerifyEmailMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomVerifyEmailMessageTextToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomVerifyEmailMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_verify_phone_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultVerifyPhoneMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetDefaultVerifyPhoneMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultVerifyPhoneMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_verify_phone_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomVerifyPhoneMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomVerifyPhoneMessageTextResponse>,
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.admin.v1.AdminService/GetCustomVerifyPhoneMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_verify_phone_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultVerifyPhoneMessageTextRequest,
>,
) -> Result<
tonic::Response<super::SetDefaultVerifyPhoneMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultVerifyPhoneMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_verify_phone_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomVerifyPhoneMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomVerifyPhoneMessageTextToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomVerifyPhoneMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_domain_claimed_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultDomainClaimedMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetDefaultDomainClaimedMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultDomainClaimedMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_domain_claimed_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomDomainClaimedMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomDomainClaimedMessageTextResponse>,
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.admin.v1.AdminService/GetCustomDomainClaimedMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_domain_claimed_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultDomainClaimedMessageTextRequest,
>,
) -> Result<
tonic::Response<super::SetDefaultDomainClaimedMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultDomainClaimedMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_domain_claimed_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomDomainClaimedMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomDomainClaimedMessageTextToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomDomainClaimedMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_passwordless_registration_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultPasswordlessRegistrationMessageTextRequest,
>,
) -> Result<
tonic::Response<
super::GetDefaultPasswordlessRegistrationMessageTextResponse,
>,
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.admin.v1.AdminService/GetDefaultPasswordlessRegistrationMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_passwordless_registration_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomPasswordlessRegistrationMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomPasswordlessRegistrationMessageTextResponse>,
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.admin.v1.AdminService/GetCustomPasswordlessRegistrationMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_passwordless_registration_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultPasswordlessRegistrationMessageTextRequest,
>,
) -> Result<
tonic::Response<
super::SetDefaultPasswordlessRegistrationMessageTextResponse,
>,
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.admin.v1.AdminService/SetDefaultPasswordlessRegistrationMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_passwordless_registration_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomPasswordlessRegistrationMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<
super::ResetCustomPasswordlessRegistrationMessageTextToDefaultResponse,
>,
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.admin.v1.AdminService/ResetCustomPasswordlessRegistrationMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_password_change_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetDefaultPasswordChangeMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetDefaultPasswordChangeMessageTextResponse>,
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.admin.v1.AdminService/GetDefaultPasswordChangeMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_password_change_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::GetCustomPasswordChangeMessageTextRequest,
>,
) -> Result<
tonic::Response<super::GetCustomPasswordChangeMessageTextResponse>,
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.admin.v1.AdminService/GetCustomPasswordChangeMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_default_password_change_message_text(
&mut self,
request: impl tonic::IntoRequest<
super::SetDefaultPasswordChangeMessageTextRequest,
>,
) -> Result<
tonic::Response<super::SetDefaultPasswordChangeMessageTextResponse>,
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.admin.v1.AdminService/SetDefaultPasswordChangeMessageText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_password_change_message_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomPasswordChangeMessageTextToDefaultRequest,
>,
) -> Result<
tonic::Response<
super::ResetCustomPasswordChangeMessageTextToDefaultResponse,
>,
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.admin.v1.AdminService/ResetCustomPasswordChangeMessageTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_default_login_texts(
&mut self,
request: impl tonic::IntoRequest<super::GetDefaultLoginTextsRequest>,
) -> Result<
tonic::Response<super::GetDefaultLoginTextsResponse>,
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.admin.v1.AdminService/GetDefaultLoginTexts",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_custom_login_texts(
&mut self,
request: impl tonic::IntoRequest<super::GetCustomLoginTextsRequest>,
) -> Result<tonic::Response<super::GetCustomLoginTextsResponse>, 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.admin.v1.AdminService/GetCustomLoginTexts",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn set_custom_login_text(
&mut self,
request: impl tonic::IntoRequest<super::SetCustomLoginTextsRequest>,
) -> Result<tonic::Response<super::SetCustomLoginTextsResponse>, 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.admin.v1.AdminService/SetCustomLoginText",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn reset_custom_login_text_to_default(
&mut self,
request: impl tonic::IntoRequest<
super::ResetCustomLoginTextsToDefaultRequest,
>,
) -> Result<
tonic::Response<super::ResetCustomLoginTextsToDefaultResponse>,
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.admin.v1.AdminService/ResetCustomLoginTextToDefault",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_iam_member_roles(
&mut self,
request: impl tonic::IntoRequest<super::ListIamMemberRolesRequest>,
) -> Result<tonic::Response<super::ListIamMemberRolesResponse>, 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.admin.v1.AdminService/ListIAMMemberRoles",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_iam_members(
&mut self,
request: impl tonic::IntoRequest<super::ListIamMembersRequest>,
) -> Result<tonic::Response<super::ListIamMembersResponse>, 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.admin.v1.AdminService/ListIAMMembers",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn add_iam_member(
&mut self,
request: impl tonic::IntoRequest<super::AddIamMemberRequest>,
) -> Result<tonic::Response<super::AddIamMemberResponse>, 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.admin.v1.AdminService/AddIAMMember",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn update_iam_member(
&mut self,
request: impl tonic::IntoRequest<super::UpdateIamMemberRequest>,
) -> Result<tonic::Response<super::UpdateIamMemberResponse>, 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.admin.v1.AdminService/UpdateIAMMember",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_iam_member(
&mut self,
request: impl tonic::IntoRequest<super::RemoveIamMemberRequest>,
) -> Result<tonic::Response<super::RemoveIamMemberResponse>, 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.admin.v1.AdminService/RemoveIAMMember",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_views(
&mut self,
request: impl tonic::IntoRequest<super::ListViewsRequest>,
) -> Result<tonic::Response<super::ListViewsResponse>, 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.admin.v1.AdminService/ListViews",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_failed_events(
&mut self,
request: impl tonic::IntoRequest<super::ListFailedEventsRequest>,
) -> Result<tonic::Response<super::ListFailedEventsResponse>, 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.admin.v1.AdminService/ListFailedEvents",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn remove_failed_event(
&mut self,
request: impl tonic::IntoRequest<super::RemoveFailedEventRequest>,
) -> Result<tonic::Response<super::RemoveFailedEventResponse>, 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.admin.v1.AdminService/RemoveFailedEvent",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn import_data(
&mut self,
request: impl tonic::IntoRequest<super::ImportDataRequest>,
) -> Result<tonic::Response<super::ImportDataResponse>, 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.admin.v1.AdminService/ImportData",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn export_data(
&mut self,
request: impl tonic::IntoRequest<super::ExportDataRequest>,
) -> Result<tonic::Response<super::ExportDataResponse>, 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.admin.v1.AdminService/ExportData",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_event_types(
&mut self,
request: impl tonic::IntoRequest<super::ListEventTypesRequest>,
) -> Result<tonic::Response<super::ListEventTypesResponse>, 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.admin.v1.AdminService/ListEventTypes",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_events(
&mut self,
request: impl tonic::IntoRequest<super::ListEventsRequest>,
) -> Result<tonic::Response<super::ListEventsResponse>, 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.admin.v1.AdminService/ListEvents",
);
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_aggregate_types(
&mut self,
request: impl tonic::IntoRequest<super::ListAggregateTypesRequest>,
) -> Result<tonic::Response<super::ListAggregateTypesResponse>, 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.admin.v1.AdminService/ListAggregateTypes",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}