dfns-sdk-rust 0.2.0

// Code generated by rust-sdk-generator. DO NOT EDIT.

#[allow(unused_imports)]
use super::types::*;

/// Delegated client for keys operations. Signed operations are split into
/// init/complete pairs so the challenge can be signed on the user side.
#[derive(Clone)]
pub struct DelegatedKeysClient {
    client: crate::client::Client,
}

impl DelegatedKeysClient {
    pub fn new(client: crate::client::Client) -> Self {
        DelegatedKeysClient { client }
    }

    /// Retrieve all keys registered for your organization.
    pub async fn list_keys(
        &self,
        query: Option<ListKeysQuery>,
    ) -> Result<ListKeysResponse, crate::error::Error> {
        let mut path = String::from("/keys");
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if let Some(v) = &query.owner {
                q.push(format!("owner={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListKeysResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for createKey: returns the challenge to sign.
    /// Pass the signed assertion to create_key_complete with the same arguments.
    pub async fn create_key_init(
        &self,
        body: CreateKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = String::from("/keys");
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for createKey: submits the signed challenge
    /// and issues the request.
    pub async fn create_key_complete(
        &self,
        body: CreateKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateKeyResponse, crate::error::Error> {
        let path = String::from("/keys");
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<CreateKeyResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for delegateKey: returns the challenge to sign.
    /// Pass the signed assertion to delegate_key_complete with the same arguments.
    pub async fn delegate_key_init(
        &self,
        key_id: String,
        body: DelegateKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}/delegate", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for delegateKey: submits the signed challenge
    /// and issues the request.
    pub async fn delegate_key_complete(
        &self,
        key_id: String,
        body: DelegateKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<DelegateKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}/delegate", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<DelegateKeyResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieves a key information by its ID.
    pub async fn get_key(&self, key_id: String) -> Result<GetKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}", urlencoding::encode(&key_id));
        self.client
            .request::<GetKeyResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for updateKey: returns the challenge to sign.
    /// Pass the signed assertion to update_key_complete with the same arguments.
    pub async fn update_key_init(
        &self,
        key_id: String,
        body: UpdateKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for updateKey: submits the signed challenge
    /// and issues the request.
    pub async fn update_key_complete(
        &self,
        key_id: String,
        body: UpdateKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<UpdateKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<UpdateKeyResponse>(
                reqwest::Method::PUT,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for deleteKey: returns the challenge to sign.
    /// Pass the signed assertion to delete_key_complete with the same arguments.
    pub async fn delete_key_init(
        &self,
        key_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}", urlencoding::encode(&key_id));
        self.client
            .create_user_action_challenge(reqwest::Method::DELETE, &path, None)
            .await
    }

    /// Finishes delegated signing for deleteKey: submits the signed challenge
    /// and issues the request.
    pub async fn delete_key_complete(
        &self,
        key_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<DeleteKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}", urlencoding::encode(&key_id));
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<DeleteKeyResponse>(
                reqwest::Method::DELETE,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for deriveKey: returns the challenge to sign.
    /// Pass the signed assertion to derive_key_complete with the same arguments.
    pub async fn derive_key_init(
        &self,
        key_id: String,
        body: DeriveKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}/derive", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for deriveKey: submits the signed challenge
    /// and issues the request.
    pub async fn derive_key_complete(
        &self,
        key_id: String,
        body: DeriveKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<DeriveKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}/derive", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<DeriveKeyResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for exportKey: returns the challenge to sign.
    /// Pass the signed assertion to export_key_complete with the same arguments.
    pub async fn export_key_init(
        &self,
        key_id: String,
        body: ExportKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}/export", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for exportKey: submits the signed challenge
    /// and issues the request.
    pub async fn export_key_complete(
        &self,
        key_id: String,
        body: ExportKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<ExportKeyResponse, crate::error::Error> {
        let path = format!("/keys/{}/export", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<ExportKeyResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// List all signature requests for a key.
    pub async fn list_signatures(
        &self,
        key_id: String,
        query: Option<ListSignaturesQuery>,
    ) -> Result<ListSignaturesResponse, crate::error::Error> {
        let mut path = format!("/keys/{}/signatures", urlencoding::encode(&key_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListSignaturesResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for generateSignature: returns the challenge to sign.
    /// Pass the signed assertion to generate_signature_complete with the same arguments.
    pub async fn generate_signature_init(
        &self,
        key_id: String,
        body: GenerateSignatureRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/keys/{}/signatures", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for generateSignature: submits the signed challenge
    /// and issues the request.
    pub async fn generate_signature_complete(
        &self,
        key_id: String,
        body: GenerateSignatureRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<GenerateSignatureResponse, crate::error::Error> {
        let path = format!("/keys/{}/signatures", urlencoding::encode(&key_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<GenerateSignatureResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieve a signature request details.
    pub async fn get_signature(
        &self,
        key_id: String,
        signature_id: String,
    ) -> Result<GetSignatureResponse, crate::error::Error> {
        let path = format!(
            "/keys/{}/signatures/{}",
            urlencoding::encode(&key_id),
            urlencoding::encode(&signature_id)
        );
        self.client
            .request::<GetSignatureResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for importKey: returns the challenge to sign.
    /// Pass the signed assertion to import_key_complete with the same arguments.
    pub async fn import_key_init(
        &self,
        body: ImportKeyRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = String::from("/keys/import");
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for importKey: submits the signed challenge
    /// and issues the request.
    pub async fn import_key_complete(
        &self,
        body: ImportKeyRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<ImportKeyResponse, crate::error::Error> {
        let path = String::from("/keys/import");
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<ImportKeyResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }
}