spiral-sdk 0.1.12

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated implementation of authenticated SDK resource facades."]
use reqwest_middleware::ClientWithMiddleware;
use spiral_contract::call::CallError;

use crate::api::organization::OrganizationClient;
use crate::api::organization::objects::*;
use crate::auth::TokenSource;
use crate::http::HttpClient;
/// Service operations sharing a connection pool and resolving credentials for every request.
#[derive(Clone, Debug)]
pub struct AuthenticatedClient {
    http: HttpClient,
    client: OrganizationClient,
}
impl AuthenticatedClient {
    /// Connect with bounded requests; configure credentials before authenticated calls.
    pub fn new(base: &str) -> Result<Self, CallError<OrganizationError>> {
        Self::from_http(HttpClient::connect(base).map_err(CallError::transport)?)
    }
    pub(crate) fn from_http(http: HttpClient) -> Result<Self, CallError<OrganizationError>> {
        let client =
            OrganizationClient::from_transport(http.base_url().as_str(), http.middleware_client())?;
        Ok(Self { http, client })
    }
    /// Reuse a connection pool with redirects disabled to protect bearer credentials.
    pub fn with_client(mut self, client: impl Into<ClientWithMiddleware>) -> Self {
        self.http = self.http.with_client(client);
        self.client = self.client.with_transport(self.http.middleware_client());
        self
    }
    /// Resolve the provider's current credential before each request and pagination fetch.
    pub fn with_token_source(mut self, provider: TokenSource) -> Self {
        self.http = self.http.with_token_source(provider);
        self
    }
    /// Create an Organization for the authenticated user. Existing Organization membership prevents
    /// creating another.
    pub async fn create_organization(
        &self,
        request: CreateOrganizationRequest,
    ) -> Result<CreateOrganizationResponse, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.create_organization_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Open an account administration setting with Organization configure permission.
    pub async fn create_portal_link(
        &self,
        request: PortalLinkRequest,
    ) -> Result<PortalLink, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.create_portal_link_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Deactivate a membership with manage-users permission. The last owner cannot be deactivated.
    pub async fn deactivate_member(
        &self,
        user_id: String,
    ) -> Result<(), CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.deactivate_member_http(auth_header, user_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Deactivate an Organization with platform administer permission.
    pub async fn deactivate_organization(
        &self,
        organization_id: String,
    ) -> Result<(), CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .deactivate_organization_http(auth_header, organization_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Invite a user to the active Organization with invite permission.
    pub async fn invite_member(
        &self,
        request: InviteMemberRequest,
    ) -> Result<InvitationResponse, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.invite_member_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List the active Organization invitations with invite permission. Page size defaults to 10
    /// and must be 1..=100.
    pub async fn list_invitations(
        &self,
        request: ListMembersRequest,
    ) -> Result<InvitationPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_invitations_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_invitations_list(
        &self,
        request: ListMembersRequest,
    ) -> crate::List<'_, Invitation> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_invitations(request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List the active Organization members with list-users permission. Each page reauthorizes the
    /// caller.
    pub async fn list_members(
        &self,
        request: ListMembersRequest,
    ) -> Result<MemberPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_members_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_members_list(&self, request: ListMembersRequest) -> crate::List<'_, Member> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_members(request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List the authenticated user memberships in ascending Organization ID order. Requires a
    /// first-party user credential.
    pub async fn list_memberships(
        &self,
        request: ListMembershipsRequest,
    ) -> Result<MembershipPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_memberships_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_memberships_list(
        &self,
        request: ListMembershipsRequest,
    ) -> crate::List<'_, Membership> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_memberships(request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List Organization records in ascending ID order with platform administer permission.
    pub async fn list_organizations(
        &self,
        request: ListOrganizationsRequest,
    ) -> Result<OrganizationPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_organizations_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_organizations_list(
        &self,
        request: ListOrganizationsRequest,
    ) -> crate::List<'_, OrganizationDetails> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_organizations(request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Reactivate an Organization with platform administer permission.
    pub async fn reactivate_organization(
        &self,
        organization_id: String,
    ) -> Result<(), CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .reactivate_organization_http(auth_header, organization_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read the active Organization storage default with Organization configure permission.
    pub async fn read_config(&self) -> Result<OrganizationConfig, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.read_config_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read the authenticated user identity and active Organization. Workload, service and
    /// delegated credentials are refused.
    pub async fn read_identity(&self) -> Result<Identity, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.read_identity_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Resend an invitation owned by the active Organization with invite permission.
    pub async fn resend_invitation(
        &self,
        invitation_id: String,
    ) -> Result<InvitationResponse, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .resend_invitation_http(auth_header, invitation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Revoke an invitation owned by the active Organization with invite permission.
    pub async fn revoke_invitation(
        &self,
        invitation_id: String,
    ) -> Result<(), CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .revoke_invitation_http(auth_header, invitation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Set a member role with manage-users permission. The last owner cannot be demoted.
    pub async fn set_member_role(
        &self,
        user_id: String,
        request: SetMemberRoleRequest,
    ) -> Result<(), CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .set_member_role_http(auth_header, user_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Synchronize one provider page of memberships for the specified Organization with platform
    /// administer permission. Only active memberships are stored; an empty result can still have a
    /// continuation. Page size defaults to 10 and must be 1..=100.
    pub async fn sync_memberships(
        &self,
        organization_id: String,
        request: ListMembersRequest,
    ) -> Result<MembershipPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .sync_memberships_http(auth_header, organization_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn sync_memberships_list(
        &self,
        organization_id: String,
        request: ListMembersRequest,
    ) -> crate::List<'_, Membership> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let organization_id = ToOwned::to_owned(&organization_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.sync_memberships(organization_id, request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Synchronize one live provider page with platform administer permission. Page size defaults
    /// to 10 and must be 1..=100. Repeat with the continuation until absent.
    pub async fn sync_organizations(
        &self,
        request: ListMembersRequest,
    ) -> Result<OrganizationIdPage, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.sync_organizations_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn sync_organizations_list(&self, request: ListMembersRequest) -> crate::List<'_, String> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.sync_organizations(request).await?;
                Ok(crate::Page {
                    items: page.items,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Set the active Organization storage default with Organization configure permission.
    /// Plaintext storage keys are vaulted before persistence.
    pub async fn write_config(
        &self,
        request: OrganizationConfig,
    ) -> Result<OrganizationConfig, CallError<OrganizationError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.write_config_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
}