gestalt-sdk 0.0.1-alpha.19

// Code generated by sdkgen. DO NOT EDIT.

//! Generated native types and clients for external_credential.proto.

use crate::codec::external_credential::{
    from_wire_exchange_external_credential_response, from_wire_external_credential,
    from_wire_list_external_credentials_response, from_wire_resolve_external_credential_response,
    to_wire_delete_external_credential_request, to_wire_exchange_external_credential_request,
    to_wire_get_external_credential_request, to_wire_list_external_credentials_request,
    to_wire_resolve_external_credential_request, to_wire_upsert_external_credential_request,
    to_wire_validate_external_credential_config_request,
};
use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
use crate::generated::v1;
use crate::rpc_support::GestaltError;

/// Native message type for `gestalt.provider.v1.DeleteExternalCredentialRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteExternalCredentialRequest {
    /// The `id` field.
    pub id: String,
}

/// Native message type for `gestalt.provider.v1.ExchangeExternalCredentialRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExchangeExternalCredentialRequest {
    /// The `provider` field.
    pub provider: String,
    /// The `connection` field.
    pub connection: String,
    /// The `connection_id` field.
    pub connection_id: String,
    /// The `credential_subject_id` field.
    pub credential_subject_id: String,
    /// The `actor_subject_id` field.
    pub actor_subject_id: String,
    /// The `instance` field.
    pub instance: String,
    /// The `auth` field; None when unset.
    pub auth: Option<ExternalCredentialAuthConfig>,
    /// The `credential_json` field.
    pub credential_json: String,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, String>,
}

/// Native message type for `gestalt.provider.v1.ExchangeExternalCredentialResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExchangeExternalCredentialResponse {
    /// The `token_response` field; None when unset.
    pub token_response: Option<ExternalCredentialTokenResponse>,
}

/// Native message type for `gestalt.provider.v1.ExternalCredential`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExternalCredential {
    /// The `id` field.
    pub id: String,
    /// The `subject_id` field.
    pub subject_id: String,
    /// The `instance` field.
    pub instance: String,
    /// The `access_token` field.
    pub access_token: String,
    /// The `refresh_token` field.
    pub refresh_token: String,
    /// The `scopes` field.
    pub scopes: String,
    /// The `expires_at` field; None when unset.
    pub expires_at: Option<std::time::SystemTime>,
    /// The `last_refreshed_at` field; None when unset.
    pub last_refreshed_at: Option<std::time::SystemTime>,
    /// The `refresh_error_count` field.
    pub refresh_error_count: i32,
    /// The `metadata_json` field.
    pub metadata_json: String,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
    /// The `updated_at` field; None when unset.
    pub updated_at: Option<std::time::SystemTime>,
    /// The `connection_id` field.
    pub connection_id: String,
}

/// Native message type for `gestalt.provider.v1.ExternalCredentialAuthConfig`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExternalCredentialAuthConfig {
    /// The `type` field.
    pub r#type: String,
    /// The `token` field.
    pub token: String,
    /// The `token_prefix` field.
    pub token_prefix: String,
    /// The `grant_type` field.
    pub grant_type: String,
    /// The `token_url` field.
    pub token_url: String,
    /// The `client_id` field.
    pub client_id: String,
    /// The `client_secret` field.
    pub client_secret: String,
    /// The `client_auth` field.
    pub client_auth: String,
    /// The `token_exchange` field.
    pub token_exchange: String,
    /// The `scopes` field.
    pub scopes: Vec<String>,
    /// The `scope_param` field.
    pub scope_param: String,
    /// The `scope_separator` field.
    pub scope_separator: String,
    /// The `token_params` field.
    pub token_params: std::collections::BTreeMap<String, String>,
    /// The `refresh_params` field.
    pub refresh_params: std::collections::BTreeMap<String, String>,
    /// The `accept_header` field.
    pub accept_header: String,
    /// The `access_token_path` field.
    pub access_token_path: String,
    /// The `token_exchange_drivers` field.
    pub token_exchange_drivers: Vec<ExternalCredentialTokenExchangeDriver>,
    /// The `refresh_token` field.
    pub refresh_token: String,
}

/// Native message type for `gestalt.provider.v1.ExternalCredentialLookup`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExternalCredentialLookup {
    /// The `subject_id` field.
    pub subject_id: String,
    /// The `instance` field.
    pub instance: String,
    /// The `connection_id` field.
    pub connection_id: String,
}

/// Native message type for `gestalt.provider.v1.ExternalCredentialTokenExchangeDriver`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExternalCredentialTokenExchangeDriver {
    /// The `type` field.
    pub r#type: String,
    /// The `target_principal` field.
    pub target_principal: String,
    /// The `scopes` field.
    pub scopes: Vec<String>,
    /// The `lifetime_seconds` field.
    pub lifetime_seconds: i32,
    /// The `endpoint` field.
    pub endpoint: String,
    /// The `params` field.
    pub params: std::collections::BTreeMap<String, String>,
}

/// Native message type for `gestalt.provider.v1.ExternalCredentialTokenResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExternalCredentialTokenResponse {
    /// The `access_token` field.
    pub access_token: String,
    /// The `refresh_token` field.
    pub refresh_token: String,
    /// The `expires_in` field.
    pub expires_in: i32,
    /// The `token_type` field.
    pub token_type: String,
    /// The `extra_json` field.
    pub extra_json: String,
    /// The `refresh_source` field.
    pub refresh_source: String,
}

/// Native message type for `gestalt.provider.v1.GetExternalCredentialRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetExternalCredentialRequest {
    /// The `lookup` field; None when unset.
    pub lookup: Option<ExternalCredentialLookup>,
}

/// Native message type for `gestalt.provider.v1.ListExternalCredentialsRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListExternalCredentialsRequest {
    /// The `subject_id` field.
    pub subject_id: String,
    /// The `instance` field.
    pub instance: String,
    /// The `connection_id` field.
    pub connection_id: String,
}

/// Native message type for `gestalt.provider.v1.ListExternalCredentialsResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListExternalCredentialsResponse {
    /// The `credentials` field.
    pub credentials: Vec<ExternalCredential>,
}

/// Native message type for `gestalt.provider.v1.ResolveExternalCredentialRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ResolveExternalCredentialRequest {
    /// The `provider` field.
    pub provider: String,
    /// The `connection` field.
    pub connection: String,
    /// The `connection_id` field.
    pub connection_id: String,
    /// The `mode` field.
    pub mode: String,
    /// The `credential_subject_id` field.
    pub credential_subject_id: String,
    /// The `actor_subject_id` field.
    pub actor_subject_id: String,
    /// The `instance` field.
    pub instance: String,
    /// The `auth` field; None when unset.
    pub auth: Option<ExternalCredentialAuthConfig>,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, String>,
}

/// Native message type for `gestalt.provider.v1.ResolveExternalCredentialResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ResolveExternalCredentialResponse {
    /// The `token` field.
    pub token: String,
    /// The `expires_at` field; None when unset.
    pub expires_at: Option<std::time::SystemTime>,
    /// The `metadata_json` field.
    pub metadata_json: String,
    /// The `params` field.
    pub params: std::collections::BTreeMap<String, String>,
    /// The `credential` field; None when unset.
    pub credential: Option<ExternalCredential>,
}

/// Native message type for `gestalt.provider.v1.UpsertExternalCredentialRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UpsertExternalCredentialRequest {
    /// The `credential` field; None when unset.
    pub credential: Option<ExternalCredential>,
    /// The `preserve_timestamps` field.
    pub preserve_timestamps: bool,
}

/// Native message type for `gestalt.provider.v1.ValidateExternalCredentialConfigRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ValidateExternalCredentialConfigRequest {
    /// The `provider` field.
    pub provider: String,
    /// The `connection` field.
    pub connection: String,
    /// The `connection_id` field.
    pub connection_id: String,
    /// The `mode` field.
    pub mode: String,
    /// The `auth` field; None when unset.
    pub auth: Option<ExternalCredentialAuthConfig>,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, String>,
}

/// Client for the `gestalt.provider.v1.ExternalCredentials` service.
pub struct ExternalCredentials {
    inner: v1::external_credentials_client::ExternalCredentialsClient<HostServiceChannel>,
    timeout: Option<std::time::Duration>,
}

impl ExternalCredentials {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::external_credentials_client::ExternalCredentialsClient::new(plain_channel(
                channel,
            )),
            timeout: None,
        }
    }

    /// Sets a deadline applied to every unary call; calls that run past it
    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    /// Connects to the `external_credentials` host service described by the environment.
    pub async fn connect() -> Result<Self, GestaltError> {
        Self::connect_named("").await
    }

    /// Connects to the named `external_credentials` host-service binding.
    pub async fn connect_named(name: &str) -> Result<Self, GestaltError> {
        Ok(Self {
            inner: v1::external_credentials_client::ExternalCredentialsClient::new(
                connect_host_service("external_credentials", name).await?,
            ),
            timeout: None,
        })
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.UpsertCredential`.
    pub async fn upsert_credential(
        &mut self,
        preserve_timestamps: bool,
        credential: Option<ExternalCredential>,
    ) -> Result<ExternalCredential, GestaltError> {
        let request = UpsertExternalCredentialRequest {
            preserve_timestamps,
            credential,
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_upsert_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.upsert_credential(tonic_request).await?;
        Ok(from_wire_external_credential(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.UpsertCredential` with the full request and response messages.
    pub async fn upsert_credential_raw(
        &mut self,
        request: UpsertExternalCredentialRequest,
    ) -> Result<ExternalCredential, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_upsert_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.upsert_credential(tonic_request).await?;
        Ok(from_wire_external_credential(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.GetCredential`.
    pub async fn get_credential(
        &mut self,
        lookup: Option<ExternalCredentialLookup>,
    ) -> Result<ExternalCredential, GestaltError> {
        let request = GetExternalCredentialRequest { lookup };
        let mut tonic_request =
            tonic::Request::new(to_wire_get_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_credential(tonic_request).await?;
        Ok(from_wire_external_credential(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.GetCredential` with the full request and response messages.
    pub async fn get_credential_raw(
        &mut self,
        request: GetExternalCredentialRequest,
    ) -> Result<ExternalCredential, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_get_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_credential(tonic_request).await?;
        Ok(from_wire_external_credential(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ListCredentials`.
    pub async fn list_credentials(
        &mut self,
        subject_id: String,
        instance: String,
        connection_id: String,
    ) -> Result<Vec<ExternalCredential>, GestaltError> {
        let request = ListExternalCredentialsRequest {
            subject_id,
            instance,
            connection_id,
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_list_external_credentials_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_list_external_credentials_response(
            self.inner
                .list_credentials(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.credentials)
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ListCredentials` with the full request and response messages.
    pub async fn list_credentials_raw(
        &mut self,
        request: ListExternalCredentialsRequest,
    ) -> Result<ListExternalCredentialsResponse, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_list_external_credentials_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_credentials(tonic_request).await?;
        Ok(from_wire_list_external_credentials_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.DeleteCredential`.
    pub async fn delete_credential(&mut self, id: String) -> Result<(), GestaltError> {
        let request = DeleteExternalCredentialRequest { id };
        let mut tonic_request =
            tonic::Request::new(to_wire_delete_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_credential(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.DeleteCredential` with the full request and response messages.
    pub async fn delete_credential_raw(
        &mut self,
        request: DeleteExternalCredentialRequest,
    ) -> Result<(), GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_delete_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_credential(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ValidateCredentialConfig`.
    pub async fn validate_credential_config(
        &mut self,
        provider: String,
        connection: String,
        connection_id: String,
        mode: String,
        auth: Option<ExternalCredentialAuthConfig>,
    ) -> Result<(), GestaltError> {
        let request = ValidateExternalCredentialConfigRequest {
            provider,
            connection,
            connection_id,
            mode,
            auth,
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_validate_external_credential_config_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.validate_credential_config(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ValidateCredentialConfig` with the full request and response messages.
    pub async fn validate_credential_config_raw(
        &mut self,
        request: ValidateExternalCredentialConfigRequest,
    ) -> Result<(), GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_validate_external_credential_config_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.validate_credential_config(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ResolveCredential`.
    #[allow(clippy::too_many_arguments)]
    pub async fn resolve_credential(
        &mut self,
        provider: String,
        connection: String,
        connection_id: String,
        mode: String,
        credential_subject_id: String,
        actor_subject_id: String,
        instance: String,
        auth: Option<ExternalCredentialAuthConfig>,
    ) -> Result<ResolveExternalCredentialResponse, GestaltError> {
        let request = ResolveExternalCredentialRequest {
            provider,
            connection,
            connection_id,
            mode,
            credential_subject_id,
            actor_subject_id,
            instance,
            auth,
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_resolve_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.resolve_credential(tonic_request).await?;
        Ok(from_wire_resolve_external_credential_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ResolveCredential` with the full request and response messages.
    pub async fn resolve_credential_raw(
        &mut self,
        request: ResolveExternalCredentialRequest,
    ) -> Result<ResolveExternalCredentialResponse, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_resolve_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.resolve_credential(tonic_request).await?;
        Ok(from_wire_resolve_external_credential_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ExchangeCredential`.
    #[allow(clippy::too_many_arguments)]
    pub async fn exchange_credential(
        &mut self,
        provider: String,
        connection: String,
        connection_id: String,
        credential_subject_id: String,
        actor_subject_id: String,
        instance: String,
        credential_json: String,
        auth: Option<ExternalCredentialAuthConfig>,
    ) -> Result<Option<ExternalCredentialTokenResponse>, GestaltError> {
        let request = ExchangeExternalCredentialRequest {
            provider,
            connection,
            connection_id,
            credential_subject_id,
            actor_subject_id,
            instance,
            credential_json,
            auth,
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_exchange_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_exchange_external_credential_response(
            self.inner
                .exchange_credential(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.token_response)
    }

    /// Calls `gestalt.provider.v1.ExternalCredentials.ExchangeCredential` with the full request and response messages.
    pub async fn exchange_credential_raw(
        &mut self,
        request: ExchangeExternalCredentialRequest,
    ) -> Result<ExchangeExternalCredentialResponse, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_exchange_external_credential_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.exchange_credential(tonic_request).await?;
        Ok(from_wire_exchange_external_credential_response(
            response.into_inner(),
        ))
    }
}