spiral-sdk 0.1.10

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

use crate::api::apps::AppsClient;
use crate::api::apps::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: AppsClient,
}
impl AuthenticatedClient {
    /// Connect with bounded requests; configure credentials before authenticated calls.
    pub fn new(base: &str) -> Result<Self, CallError<AppsError>> {
        Self::from_http(HttpClient::connect(base).map_err(CallError::transport)?)
    }
    pub(crate) fn from_http(http: HttpClient) -> Result<Self, CallError<AppsError>> {
        let client =
            AppsClient::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: reqwest::Client) -> 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
    }
    /// Approve the latest request of an installation. Only an Organization owner can approve. The
    /// Application must have a background identity.
    pub async fn approve_installation(
        &self,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .approve_installation_http(auth_header, installation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Create an active Application in a Project. The service generates the client ID of the
    /// Application. Only a Project administrator can create an Application.
    pub async fn create_application(
        &self,
        project_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .create_application_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Decide this user authorization. Required installation access must be active before approval.
    /// Return the browser to redirectTo to complete OAuth.
    pub async fn decide_consent(
        &self,
        challenge: String,
        request: ConsentDecision,
    ) -> Result<ConsentRedirect, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .decide_consent_http(auth_header, challenge, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Permanently delete an Application and uninstall it from every Organization. Only a Project
    /// administrator can delete an Application. When the response is `RegistrationUnavailable`,
    /// send the same request again. Access tokens that were issued before the deletion stay valid
    /// until they expire.
    pub async fn delete_application(
        &self,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .delete_application_http(auth_header, application_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read an Application. A viewer of the Application's Project can read it.
    pub async fn get_application(
        &self,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .get_application_http(auth_header, application_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read the authorization bound to the authenticated first-party user and Organization.
    pub async fn get_consent_request(
        &self,
        challenge: String,
    ) -> Result<ConsentRequest, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.get_consent_request_http(auth_header, challenge),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires an installation token. Returns current metadata even when suspended; this does not
    /// grant project access.
    pub async fn get_current_installation(
        &self,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.get_current_installation_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires an Organization member. Shows a public Application, an Application owned by the
    /// Organization, or one already installed there. Does not grant access or permit viewing the
    /// developer's credentials or callbacks.
    pub async fn get_installable_application(
        &self,
        application_id: String,
    ) -> Result<InstallableApplication, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .get_installable_application_http(auth_header, application_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read an installation in your Organization. Any member of the Organization can read it.
    pub async fn get_installation(
        &self,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .get_installation_http(auth_header, installation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read which Applications and MCP clients the users of your Organization can sign in to. Only
    /// an Organization owner can read it.
    pub async fn get_organization_app_access(
        &self,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.get_organization_app_access_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires an app token obtained with private-key client authentication or a trusted issuer
    /// JWT-bearer exchange. It grants no customer data access.
    pub async fn get_self(&self) -> Result<Application, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.get_self_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires an app token. Installations belonging to another app return NotFound.
    pub async fn get_self_installation(
        &self,
        installation_id: String,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .get_self_installation_http(auth_header, installation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires a delegated user token with projects:read and current Organization membership. The
    /// app and Organization come from the credential.
    pub async fn get_user_installation(&self) -> Result<UserInstallation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.get_user_installation_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List the Organizations where your Application is installed. A viewer of the Application's
    /// Project can list them.
    pub async fn list_application_installations(
        &self,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .list_application_installations_http(auth_header, application_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_application_installations_list(
        &self,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, Installation> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let application_id = ToOwned::to_owned(&application_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self
                    .list_application_installations(application_id, request)
                    .await?;
                Ok(crate::Page {
                    items: page.installations,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List the Applications of a Project. The list includes suspended and deleted Applications. A
    /// Project viewer can list them.
    pub async fn list_applications(
        &self,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> Result<ApplicationPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .list_applications_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_applications_list(
        &self,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, Application> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let project_id = ToOwned::to_owned(&project_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_applications(project_id, request).await?;
                Ok(crate::Page {
                    items: page.applications,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Requires an installation token and approved projects:read. Returns only currently authorized
    /// live projects. Pending or inactive grants return no projects.
    pub async fn list_installation_projects(
        &self,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .list_installation_projects_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_installation_projects_list(
        &self,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, InstallationProject> {
        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_installation_projects(request).await?;
                Ok(crate::Page {
                    items: page.projects,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List the installations in your Organization. Any member of the Organization can list them.
    pub async fn list_installations(
        &self,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_installations_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_installations_list(
        &self,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, Installation> {
        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_installations(request).await?;
                Ok(crate::Page {
                    items: page.installations,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List the resource scopes that an Application can request. Each scope has a description that
    /// you can show to users.
    pub async fn list_scopes(&self) -> Result<ApplicationScopes, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.list_scopes_http(auth_header),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Requires an app token. Includes only this app's requested, active and suspended
    /// installations.
    pub async fn list_self_installations(
        &self,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .list_self_installations_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_self_installations_list(
        &self,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, Installation> {
        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_self_installations(request).await?;
                Ok(crate::Page {
                    items: page.installations,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Requires a delegated user token with projects:read. The installation must belong to its app
    /// and Organization. Returns the intersection of current user and approved installation project
    /// access.
    pub async fn list_user_installation_projects(
        &self,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .list_user_installation_projects_http(auth_header, installation_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_user_installation_projects_list(
        &self,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> crate::List<'_, InstallationProject> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let installation_id = ToOwned::to_owned(&installation_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self
                    .list_user_installation_projects(installation_id, request)
                    .await?;
                Ok(crate::Page {
                    items: page.projects,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Replace the configuration of an Application. The Application stays in its Project. Only a
    /// Project administrator can update an Application. When the response is
    /// `RegistrationUnavailable`, the Application does not change; send the same request again.
    pub async fn put_application(
        &self,
        application_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .put_application_http(auth_header, application_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Replace which Applications and MCP clients the users of your Organization can sign in to.
    /// Only an Organization owner can set it. Sign-in and refresh apply the new setting from their
    /// next request.
    pub async fn put_organization_app_access(
        &self,
        request: OrganizationAppAccess,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .put_organization_app_access_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Request that an Application be installed in your Organization, or request more scopes or
    /// Projects for an existing installation. Any member of the Organization can send a request.
    /// The scopes must be registered on the Application. Until an owner approves the request, the
    /// installation keeps its earlier approval.
    pub async fn request_installation(
        &self,
        request: InstallationRequest,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.request_installation_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Only an Organization owner can approve or decline the displayed request. Returns Conflict if
    /// it changed. Declining an update preserves current access; declining a new installation
    /// removes it. The response describes the reviewed installation.
    pub async fn review_installation(
        &self,
        installation_id: String,
        request: InstallationReview,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .review_installation_http(auth_header, installation_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Suspend or resume an approved installation. Only an Organization owner can change it. A
    /// suspended installation stops at its next request, even with an unexpired token.
    pub async fn set_installation_status(
        &self,
        installation_id: String,
        request: InstallationStatusChange,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client
                .set_installation_status_http(auth_header, installation_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Remove an installation and all of its access. Only an Organization owner can uninstall.
    /// Tokens that were already issued stop working at their next request.
    pub async fn uninstall(
        &self,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(60),
            self.client.uninstall_http(auth_header, installation_id),
        )
        .await
        .map_err(CallError::transport)?
    }
}