dfns-sdk-rust 0.2.0

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

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

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

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

    /// Retrieves the list of Vaults in your organization.
    pub async fn list_vaults(
        &self,
        query: Option<ListVaultsQuery>,
    ) -> Result<ListVaultsResponse, crate::error::Error> {
        let mut path = String::from("/vaults");
        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::<ListVaultsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

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

    /// Finishes delegated signing for createVault: submits the signed challenge
    /// and issues the request.
    pub async fn create_vault_complete(
        &self,
        body: CreateVaultRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateVaultResponse, crate::error::Error> {
        let path = String::from("/vaults");
        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::<CreateVaultResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for createVaultAddress: returns the challenge to sign.
    /// Pass the signed assertion to create_vault_address_complete with the same arguments.
    pub async fn create_vault_address_init(
        &self,
        vault_id: String,
        body: CreateVaultAddressRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}/addresses", urlencoding::encode(&vault_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 createVaultAddress: submits the signed challenge
    /// and issues the request.
    pub async fn create_vault_address_complete(
        &self,
        vault_id: String,
        body: CreateVaultAddressRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateVaultAddressResponse, crate::error::Error> {
        let path = format!("/vaults/{}/addresses", urlencoding::encode(&vault_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::<CreateVaultAddressResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Lists a vault's locks, active and released.
    pub async fn list_vault_locks(
        &self,
        vault_id: String,
        query: Option<ListVaultLocksQuery>,
    ) -> Result<ListVaultLocksResponse, crate::error::Error> {
        let mut path = format!("/vaults/{}/locks", urlencoding::encode(&vault_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 let Some(v) = &query.network {
                q.push(format!("network={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.tid {
                q.push(format!("tid={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListVaultLocksResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for createVaultLock: returns the challenge to sign.
    /// Pass the signed assertion to create_vault_lock_complete with the same arguments.
    pub async fn create_vault_lock_init(
        &self,
        vault_id: String,
        body: CreateVaultLockRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}/locks", urlencoding::encode(&vault_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 createVaultLock: submits the signed challenge
    /// and issues the request.
    pub async fn create_vault_lock_complete(
        &self,
        vault_id: String,
        body: CreateVaultLockRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateVaultLockResponse, crate::error::Error> {
        let path = format!("/vaults/{}/locks", urlencoding::encode(&vault_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::<CreateVaultLockResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for createVaultTransfer: returns the challenge to sign.
    /// Pass the signed assertion to create_vault_transfer_complete with the same arguments.
    pub async fn create_vault_transfer_init(
        &self,
        vault_id: String,
        body: CreateVaultTransferRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}/transfers", urlencoding::encode(&vault_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 createVaultTransfer: submits the signed challenge
    /// and issues the request.
    pub async fn create_vault_transfer_complete(
        &self,
        vault_id: String,
        body: CreateVaultTransferRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateVaultTransferResponse, crate::error::Error> {
        let path = format!("/vaults/{}/transfers", urlencoding::encode(&vault_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::<CreateVaultTransferResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieves a vault lock by its ID.
    pub async fn get_vault_lock(
        &self,
        vault_id: String,
        lock_id: String,
    ) -> Result<GetVaultLockResponse, crate::error::Error> {
        let path = format!(
            "/vaults/{}/locks/{}",
            urlencoding::encode(&vault_id),
            urlencoding::encode(&lock_id)
        );
        self.client
            .request::<GetVaultLockResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

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

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

    /// Retrieves a Vault by its ID.
    pub async fn get_vault(
        &self,
        vault_id: String,
    ) -> Result<GetVaultResponse, crate::error::Error> {
        let path = format!("/vaults/{}", urlencoding::encode(&vault_id));
        self.client
            .request::<GetVaultResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for updateVault: returns the challenge to sign.
    /// Pass the signed assertion to update_vault_complete with the same arguments.
    pub async fn update_vault_init(
        &self,
        vault_id: String,
        body: UpdateVaultRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}", urlencoding::encode(&vault_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 updateVault: submits the signed challenge
    /// and issues the request.
    pub async fn update_vault_complete(
        &self,
        vault_id: String,
        body: UpdateVaultRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<UpdateVaultResponse, crate::error::Error> {
        let path = format!("/vaults/{}", urlencoding::encode(&vault_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::<UpdateVaultResponse>(
                reqwest::Method::PUT,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Lists a vault's assets with balances (available/quarantined/locked) and USD valuation.
    pub async fn list_vault_assets(
        &self,
        vault_id: String,
        query: Option<ListVaultAssetsQuery>,
    ) -> Result<ListVaultAssetsResponse, crate::error::Error> {
        let mut path = format!("/vaults/{}/assets", urlencoding::encode(&vault_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.show_unverified {
                q.push(format!(
                    "showUnverified={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if let Some(v) = &query.network {
                q.push(format!("network={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListVaultAssetsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Lists a vault's balance entries.
    pub async fn list_vault_balances(
        &self,
        vault_id: String,
        query: Option<ListVaultBalancesQuery>,
    ) -> Result<ListVaultBalancesResponse, crate::error::Error> {
        let mut path = format!("/vaults/{}/balances", urlencoding::encode(&vault_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 let Some(v) = &query.kind {
                q.push(format!("kind={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.network {
                q.push(format!("network={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.tid {
                q.push(format!("tid={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListVaultBalancesResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for releaseQuarantine: returns the challenge to sign.
    /// Pass the signed assertion to release_quarantine_complete with the same arguments.
    pub async fn release_quarantine_init(
        &self,
        vault_id: String,
        quarantine_id: String,
        body: ReleaseQuarantineRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/vaults/{}/quarantines/{}/release",
            urlencoding::encode(&vault_id),
            urlencoding::encode(&quarantine_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 releaseQuarantine: submits the signed challenge
    /// and issues the request.
    pub async fn release_quarantine_complete(
        &self,
        vault_id: String,
        quarantine_id: String,
        body: ReleaseQuarantineRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<ReleaseQuarantineResponse, crate::error::Error> {
        let path = format!(
            "/vaults/{}/quarantines/{}/release",
            urlencoding::encode(&vault_id),
            urlencoding::encode(&quarantine_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::<ReleaseQuarantineResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for tagVault: returns the challenge to sign.
    /// Pass the signed assertion to tag_vault_complete with the same arguments.
    pub async fn tag_vault_init(
        &self,
        vault_id: String,
        body: TagVaultRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}/tags", urlencoding::encode(&vault_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 tagVault: submits the signed challenge
    /// and issues the request.
    pub async fn tag_vault_complete(
        &self,
        vault_id: String,
        body: TagVaultRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<TagVaultResponse, crate::error::Error> {
        let path = format!("/vaults/{}/tags", urlencoding::encode(&vault_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::<TagVaultResponse>(
                reqwest::Method::PUT,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for untagVault: returns the challenge to sign.
    /// Pass the signed assertion to untag_vault_complete with the same arguments.
    pub async fn untag_vault_init(
        &self,
        vault_id: String,
        body: UntagVaultRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/vaults/{}/tags", urlencoding::encode(&vault_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::DELETE, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for untagVault: submits the signed challenge
    /// and issues the request.
    pub async fn untag_vault_complete(
        &self,
        vault_id: String,
        body: UntagVaultRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<UntagVaultResponse, crate::error::Error> {
        let path = format!("/vaults/{}/tags", urlencoding::encode(&vault_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::<UntagVaultResponse>(
                reqwest::Method::DELETE,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }
}