spiral-sdk 0.1.11

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated reqwest client with typed errors and streaming bodies."]

use async_trait::async_trait;
use futures::{Stream, TryStreamExt, stream};
use reqwest::Url;
use reqwest_middleware::ClientWithMiddleware;
use spiral_contract::auth::AuthHeader;
use spiral_contract::call::{CallError, ServiceFailure};
use spiral_contract::error::ErrorEnvelope;

use crate::api::apps::AppsApi;
use crate::api::apps::objects::*;
use crate::http::default_http_client;
/// HTTP client for the apps service.
#[derive(Clone)]
pub struct AppsClient {
    http: ClientWithMiddleware,
    base: Url,
}

impl std::fmt::Debug for AppsClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AppsClient")
            .field("base", &self.base)
            .finish_non_exhaustive()
    }
}

impl AppsClient {
    /// Create a redirect-disabled client; base may contain a deployment prefix.
    pub fn new(base: &str) -> Result<Self, CallError<AppsError>> {
        let http = default_http_client().map_err(CallError::transport)?;
        Self::from_http(base, http)
    }
    /// Use an existing connection pool with redirects disabled.
    pub fn from_http(
        base: &str,
        http: impl Into<ClientWithMiddleware>,
    ) -> Result<Self, CallError<AppsError>> {
        Self::from_transport(base, http.into())
    }
    /// Use a host-owned connection pool and instrumentation. Redirects must be disabled.
    pub fn from_transport(
        base: &str,
        http: ClientWithMiddleware,
    ) -> Result<Self, CallError<AppsError>> {
        let base =
            Url::parse(base).map_err(|_| CallError::<AppsError>::protocol("invalid base URL"))?;
        if !matches!(base.scheme(), "http" | "https")
            || base.host_str().is_none()
            || !base.username().is_empty()
            || base.password().is_some()
            || base.query().is_some()
            || base.fragment().is_some()
        {
            return Err(CallError::<AppsError>::protocol("invalid base URL"));
        }
        Ok(Self { http, base })
    }
    /// Replace the host-owned connection pool and instrumentation. Redirects must be disabled.
    pub fn with_transport(mut self, http: ClientWithMiddleware) -> Self {
        self.http = http;
        self
    }
    /// Supply transport instrumentation or custom connection policy.
    ///
    /// The caller must disable redirects to protect bearer credentials.
    pub fn with_http(mut self, http: impl Into<ClientWithMiddleware>) -> Self {
        self.http = http.into();
        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_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("approve");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        project_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        challenge: String,
        request: ConsentDecision,
    ) -> Result<ConsentRedirect, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("consent");
            let segment = challenge.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            let segment = application_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.delete(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Read an Application. A viewer of the Application's Project can read it.
    pub async fn get_application_http(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            let segment = application_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Read the authorization bound to the authenticated first-party user and Organization.
    pub async fn get_consent_request_http(
        &self,
        auth_header: AuthHeader,
        challenge: String,
    ) -> Result<ConsentRequest, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("consent");
            let segment = challenge.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Requires an installation token. Returns current metadata even when suspended; this does not
    /// grant project access.
    pub async fn get_current_installation_http(
        &self,
        auth_header: AuthHeader,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installation");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<InstallableApplication, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installable");
            let segment = application_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Read an installation in your Organization. Any member of the Organization can read it.
    pub async fn get_installation_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("organization-access");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
    ) -> Result<Application, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("self");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Requires an app token. Installations belonging to another app return NotFound.
    pub async fn get_self_installation_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("self");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
    ) -> Result<UserInstallation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("user");
            path.push("installation");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// List the Organizations where your Application is installed. A viewer of the Application's
    /// Project can list them.
    pub async fn list_application_installations_http(
        &self,
        auth_header: AuthHeader,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            let segment = application_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("installations");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_application_installations_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| {
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let application_id = application_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .list_application_installations_http(
                        auth_header.clone(),
                        application_id,
                        request.clone(),
                    )
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<AppsError>::protocol("invalid pagination token"));
                }
                request.page_token = next;
                let next_request = request.page_token.is_some().then_some(request);
                Ok(Some((page, next_request)))
            }
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_application_installations_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<Installation, CallError<AppsError>>> + 'a {
        self.list_application_installations_pages(auth_header, application_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.installations
                        .into_iter()
                        .map(Ok::<_, CallError<AppsError>>),
                )
            })
            .try_flatten()
    }
    /// List the Applications of a Project. The list includes suspended and deleted Applications. A
    /// Project viewer can list them.
    pub async fn list_applications_http(
        &self,
        auth_header: AuthHeader,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> Result<ApplicationPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("list");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_applications_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<ApplicationPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| {
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let project_id = project_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .list_applications_http(auth_header.clone(), project_id, request.clone())
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<AppsError>::protocol("invalid pagination token"));
                }
                request.page_token = next;
                let next_request = request.page_token.is_some().then_some(request);
                Ok(Some((page, next_request)))
            }
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_applications_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<Application, CallError<AppsError>>> + 'a {
        self.list_applications_pages(auth_header, project_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.applications
                        .into_iter()
                        .map(Ok::<_, CallError<AppsError>>),
                )
            })
            .try_flatten()
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installation");
            path.push("projects");
            path.push("list");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_installation_projects_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationProjectPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| async move {
            let Some(mut request) = request else {
                return Ok(None);
            };
            let page = self
                .list_installation_projects_http(auth_header.clone(), request.clone())
                .await?;
            let next = page.next_page_token.clone();
            if next
                .as_ref()
                .is_some_and(|token| token.is_empty() || Some(token) == request.page_token.as_ref())
            {
                return Err(CallError::<AppsError>::protocol("invalid pagination token"));
            }
            request.page_token = next;
            let next_request = request.page_token.is_some().then_some(request);
            Ok(Some((page, next_request)))
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_installation_projects_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationProject, CallError<AppsError>>> + 'a {
        self.list_installation_projects_pages(auth_header, request)
            .map_ok(|page| {
                stream::iter(page.projects.into_iter().map(Ok::<_, CallError<AppsError>>))
            })
            .try_flatten()
    }
    /// List the installations in your Organization. Any member of the Organization can list them.
    pub async fn list_installations_http(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            path.push("list");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_installations_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| async move {
            let Some(mut request) = request else {
                return Ok(None);
            };
            let page = self
                .list_installations_http(auth_header.clone(), request.clone())
                .await?;
            let next = page.next_page_token.clone();
            if next
                .as_ref()
                .is_some_and(|token| token.is_empty() || Some(token) == request.page_token.as_ref())
            {
                return Err(CallError::<AppsError>::protocol("invalid pagination token"));
            }
            request.page_token = next;
            let next_request = request.page_token.is_some().then_some(request);
            Ok(Some((page, next_request)))
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_installations_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<Installation, CallError<AppsError>>> + 'a {
        self.list_installations_pages(auth_header, request)
            .map_ok(|page| {
                stream::iter(
                    page.installations
                        .into_iter()
                        .map(Ok::<_, CallError<AppsError>>),
                )
            })
            .try_flatten()
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
    ) -> Result<ApplicationScopes, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("scopes");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Requires an app token. Includes only this app's requested, active and suspended
    /// installations.
    pub async fn list_self_installations_http(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("self");
            path.push("installations");
            path.push("list");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_self_installations_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| async move {
            let Some(mut request) = request else {
                return Ok(None);
            };
            let page = self
                .list_self_installations_http(auth_header.clone(), request.clone())
                .await?;
            let next = page.next_page_token.clone();
            if next
                .as_ref()
                .is_some_and(|token| token.is_empty() || Some(token) == request.page_token.as_ref())
            {
                return Err(CallError::<AppsError>::protocol("invalid pagination token"));
            }
            request.page_token = next;
            let next_request = request.page_token.is_some().then_some(request);
            Ok(Some((page, next_request)))
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_self_installations_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<Installation, CallError<AppsError>>> + 'a {
        self.list_self_installations_pages(auth_header, request)
            .map_ok(|page| {
                stream::iter(
                    page.installations
                        .into_iter()
                        .map(Ok::<_, CallError<AppsError>>),
                )
            })
            .try_flatten()
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("user");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("projects");
            path.push("list");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Fetch pages lazily, retaining the request filters and stopping when the token is absent.
    /// Dropping the stream cancels an active request; no later page is prefetched.
    pub fn list_user_installation_projects_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationProjectPage, CallError<AppsError>>> + 'a {
        stream::try_unfold(Some(request), move |request| {
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let installation_id = installation_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .list_user_installation_projects_http(
                        auth_header.clone(),
                        installation_id,
                        request.clone(),
                    )
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<AppsError>::protocol("invalid pagination token"));
                }
                request.page_token = next;
                let next_request = request.page_token.is_some().then_some(request);
                Ok(Some((page, next_request)))
            }
        })
    }
    /// Yield items lazily, continuing across empty pages that have a continuation token.
    pub fn list_user_installation_projects_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> impl Stream<Item = Result<InstallationProject, CallError<AppsError>>> + 'a {
        self.list_user_installation_projects_pages(auth_header, installation_id, request)
            .map_ok(|page| {
                stream::iter(page.projects.into_iter().map(Ok::<_, CallError<AppsError>>))
            })
            .try_flatten()
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        application_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            let segment = application_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.put(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        request: OrganizationAppAccess,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("organization-access");
        }
        let builder = self.http.put(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        request: InstallationRequest,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: InstallationReview,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("review");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: InstallationStatusChange,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("status");
        }
        let builder = self.http.put(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// 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_http(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<AppsError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("apps");
            path.push("installations");
            let segment = installation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<AppsError>::protocol("dot path segment"));
            }
            path.push(&segment);
        }
        let builder = self.http.delete(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    async fn send(
        &self,
        builder: reqwest_middleware::RequestBuilder,
        expected_media: &str,
    ) -> Result<reqwest::Response, CallError<AppsError>> {
        let response = builder
            .timeout(std::time::Duration::from_secs(60))
            .send()
            .await
            .map_err(CallError::transport)?;
        let status = response.status();
        if !status.is_success() {
            let status = status.as_u16();
            let content_type = response
                .headers()
                .get("content-type")
                .and_then(|value| value.to_str().ok())
                .map(str::to_owned);
            let (bytes, truncated) =
                bounded_error_body::<AppsError>(response, 64 * 1024, status, content_type.clone())
                    .await?;
            if truncated {
                return Err(CallError::unknown_remote(status, content_type, bytes, true));
            }
            return match serde_json::from_slice::<ErrorEnvelope>(&bytes) {
                Ok(envelope) => Err(CallError::Service(ServiceFailure::remote(status, envelope))),
                Err(_) => Err(CallError::unknown_remote(
                    status,
                    content_type,
                    bytes,
                    false,
                )),
            };
        }
        if !media_matches(&response, expected_media) {
            return Err(CallError::protocol_response(
                status.as_u16(),
                "unexpected response media type",
            ));
        }
        Ok(response)
    }
}

fn media_matches(response: &reqwest::Response, expected: &str) -> bool {
    response
        .headers()
        .get("content-type")
        .and_then(|value| value.to_str().ok())
        .and_then(|value| value.split(';').next())
        .is_some_and(|value| value.trim().eq_ignore_ascii_case(expected))
}

async fn bounded_body(
    mut response: reqwest::Response,
    limit: usize,
) -> Result<Vec<u8>, CallError<AppsError>> {
    let status = response.status().as_u16();
    let mut result = Vec::new();
    while let Some(chunk) = response
        .chunk()
        .await
        .map_err(|error| CallError::transport_response(status, error))?
    {
        if chunk.len() > limit.saturating_sub(result.len()) {
            return Err(CallError::protocol_response(
                status,
                "response exceeds JSON size limit",
            ));
        }
        result.extend_from_slice(&chunk);
    }
    Ok(result)
}

async fn bounded_error_body<E>(
    mut response: reqwest::Response,
    limit: usize,
    status: u16,
    content_type: Option<String>,
) -> Result<(Vec<u8>, bool), CallError<E>> {
    let mut result = Vec::new();
    loop {
        let chunk = response.chunk().await.map_err(|error| {
            CallError::unreadable_remote(status, content_type.clone(), result.clone(), error)
        })?;
        let Some(chunk) = chunk else {
            return Ok((result, false));
        };
        let remaining = limit.saturating_sub(result.len());
        if chunk.len() > remaining {
            result.extend_from_slice(&chunk[..remaining]);
            return Ok((result, true));
        }
        result.extend_from_slice(&chunk);
    }
}
#[async_trait]
impl AppsApi for AppsClient {
    async fn approve_installation(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let response = Self::approve_installation_http(self, auth_header, installation_id).await?;
        Ok(response)
    }
    async fn create_application(
        &self,
        auth_header: AuthHeader,
        project_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let response =
            Self::create_application_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn decide_consent(
        &self,
        auth_header: AuthHeader,
        challenge: String,
        request: ConsentDecision,
    ) -> Result<ConsentRedirect, CallError<AppsError>> {
        let response = Self::decide_consent_http(self, auth_header, challenge, request).await?;
        Ok(response)
    }
    async fn delete_application(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let response = Self::delete_application_http(self, auth_header, application_id).await?;
        Ok(response)
    }
    async fn get_application(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<Application, CallError<AppsError>> {
        let response = Self::get_application_http(self, auth_header, application_id).await?;
        Ok(response)
    }
    async fn get_consent_request(
        &self,
        auth_header: AuthHeader,
        challenge: String,
    ) -> Result<ConsentRequest, CallError<AppsError>> {
        let response = Self::get_consent_request_http(self, auth_header, challenge).await?;
        Ok(response)
    }
    async fn get_current_installation(
        &self,
        auth_header: AuthHeader,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let response = Self::get_current_installation_http(self, auth_header).await?;
        Ok(response)
    }
    async fn get_installable_application(
        &self,
        auth_header: AuthHeader,
        application_id: String,
    ) -> Result<InstallableApplication, CallError<AppsError>> {
        let response =
            Self::get_installable_application_http(self, auth_header, application_id).await?;
        Ok(response)
    }
    async fn get_installation(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let response = Self::get_installation_http(self, auth_header, installation_id).await?;
        Ok(response)
    }
    async fn get_organization_app_access(
        &self,
        auth_header: AuthHeader,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let response = Self::get_organization_app_access_http(self, auth_header).await?;
        Ok(response)
    }
    async fn get_self(&self, auth_header: AuthHeader) -> Result<Application, CallError<AppsError>> {
        let response = Self::get_self_http(self, auth_header).await?;
        Ok(response)
    }
    async fn get_self_installation(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<InstallationDetails, CallError<AppsError>> {
        let response = Self::get_self_installation_http(self, auth_header, installation_id).await?;
        Ok(response)
    }
    async fn get_user_installation(
        &self,
        auth_header: AuthHeader,
    ) -> Result<UserInstallation, CallError<AppsError>> {
        let response = Self::get_user_installation_http(self, auth_header).await?;
        Ok(response)
    }
    async fn list_application_installations(
        &self,
        auth_header: AuthHeader,
        application_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let response =
            Self::list_application_installations_http(self, auth_header, application_id, request)
                .await?;
        Ok(response)
    }
    async fn list_applications(
        &self,
        auth_header: AuthHeader,
        project_id: String,
        request: ListApplicationsRequest,
    ) -> Result<ApplicationPage, CallError<AppsError>> {
        let response = Self::list_applications_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn list_installation_projects(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let response = Self::list_installation_projects_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn list_installations(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let response = Self::list_installations_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn list_scopes(
        &self,
        auth_header: AuthHeader,
    ) -> Result<ApplicationScopes, CallError<AppsError>> {
        let response = Self::list_scopes_http(self, auth_header).await?;
        Ok(response)
    }
    async fn list_self_installations(
        &self,
        auth_header: AuthHeader,
        request: ListApplicationsRequest,
    ) -> Result<InstallationPage, CallError<AppsError>> {
        let response = Self::list_self_installations_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn list_user_installation_projects(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: ListApplicationsRequest,
    ) -> Result<InstallationProjectPage, CallError<AppsError>> {
        let response =
            Self::list_user_installation_projects_http(self, auth_header, installation_id, request)
                .await?;
        Ok(response)
    }
    async fn put_application(
        &self,
        auth_header: AuthHeader,
        application_id: String,
        request: ApplicationConfiguration,
    ) -> Result<Application, CallError<AppsError>> {
        let response =
            Self::put_application_http(self, auth_header, application_id, request).await?;
        Ok(response)
    }
    async fn put_organization_app_access(
        &self,
        auth_header: AuthHeader,
        request: OrganizationAppAccess,
    ) -> Result<OrganizationAppAccess, CallError<AppsError>> {
        let response = Self::put_organization_app_access_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn request_installation(
        &self,
        auth_header: AuthHeader,
        request: InstallationRequest,
    ) -> Result<Installation, CallError<AppsError>> {
        let response = Self::request_installation_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn review_installation(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: InstallationReview,
    ) -> Result<Installation, CallError<AppsError>> {
        let response =
            Self::review_installation_http(self, auth_header, installation_id, request).await?;
        Ok(response)
    }
    async fn set_installation_status(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
        request: InstallationStatusChange,
    ) -> Result<Installation, CallError<AppsError>> {
        let response =
            Self::set_installation_status_http(self, auth_header, installation_id, request).await?;
        Ok(response)
    }
    async fn uninstall(
        &self,
        auth_header: AuthHeader,
        installation_id: String,
    ) -> Result<Installation, CallError<AppsError>> {
        let response = Self::uninstall_http(self, auth_header, installation_id).await?;
        Ok(response)
    }
}