spiral-sdk 0.1.12

// 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::catalog::CatalogApi;
use crate::api::catalog::objects::*;
use crate::http::default_http_client;
/// HTTP client for the catalog service.
#[derive(Clone)]
pub struct CatalogClient {
    http: ClientWithMiddleware,
    base: Url,
}

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

impl CatalogClient {
    /// Create a redirect-disabled client; base may contain a deployment prefix.
    pub fn new(base: &str) -> Result<Self, CallError<CatalogError>> {
        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<CatalogError>> {
        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<CatalogError>> {
        let base = Url::parse(base)
            .map_err(|_| CallError::<CatalogError>::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::<CatalogError>::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
    }
    /// Compare a base and a head commit. The response contains the exact number of commits that
    /// each side has and the other does not, and a bounded part of the graph that only the head
    /// has. When the comparison is larger than the traversal limits, the response is
    /// `CommitTraversalLimitExceeded`. You must have permission to read the project.
    pub async fn compare_commits_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CompareCommitsRequest,
    ) -> Result<CompareCommitsResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            path.push("compare");
        }
        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"))
    }
    /// Create a branch at the commit that the target selector identifies. The selector is resolved
    /// one time. To retry, send the same request with the same idempotency key. You must have
    /// permission to create branches.
    pub async fn create_branch_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CreateBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
        }
        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"))
    }
    /// Create an immutable tag at the commit that the target selector identifies. You cannot move
    /// or delete a tag. You must have permission to create tags.
    pub async fn create_tag_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CreateTagRequest,
    ) -> Result<Tag, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("tags");
        }
        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"))
    }
    /// Mark a branch as deleted and return the deleted branch. The commits and the event history of
    /// the branch stay available. The service validates if you can delete the main branch. You must
    /// have permission to delete branches.
    pub async fn delete_branch_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: DeleteBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
            let segment = branch_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("delete");
        }
        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"))
    }
    /// Return all net changes to resources and namespace bindings between two commits. The response
    /// is complete. It is not paged or truncated. When the result is too large, the response is
    /// `CatalogLimitExceeded`. You must have permission to read the project.
    pub async fn diff_state_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: DiffStateRequest,
    ) -> Result<DiffStateResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            path.push("diff");
        }
        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"))
    }
    /// Prepare the Catalog of a project and return its main branch. You can send this request more
    /// than once. When the Catalog exists, the response contains the current main branch. You must
    /// have permission to initialize the project.
    pub async fn initialize_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
    ) -> Result<Branch, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("initialize");
        }
        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"))
    }
    /// List the live branches of the project. To include deleted branches, set `includeDeleted`.
    /// Branches are in order of name and identity. When branches change during a listing, a branch
    /// can be skipped or repeated. Each page token keeps `includeDeleted` and the scope of the
    /// first request. You must have permission to list branches.
    pub async fn list_branches_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ListBranchesRequest,
    ) -> Result<ListBranchesResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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_branches_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ListBranchesRequest,
    ) -> impl Stream<Item = Result<ListBranchesResponse, CallError<CatalogError>>> + '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_branches_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.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::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_branches_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ListBranchesRequest,
    ) -> impl Stream<Item = Result<Branch, CallError<CatalogError>>> + 'a {
        self.list_branches_pages(auth_header, project_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.branches
                        .into_iter()
                        .map(Ok::<_, CallError<CatalogError>>),
                )
            })
            .try_flatten()
    }
    /// List the bindings in a namespace scope at one immutable commit. Each page token keeps the
    /// scope and the commit of the first request. To read a newer commit, start a new listing. You
    /// must have permission to read the project state.
    pub async fn list_namespace_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ListNamespaceRequest,
    ) -> Result<NamespacePage, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("namespace");
            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_namespace_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ListNamespaceRequest,
    ) -> impl Stream<Item = Result<NamespacePage, CallError<CatalogError>>> + '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();
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let commit_id = commit_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .list_namespace_http(
                        auth_header.clone(),
                        project_id,
                        commit_id,
                        request.clone(),
                    )
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::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_namespace_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ListNamespaceRequest,
    ) -> impl Stream<Item = Result<NamespaceEntry, CallError<CatalogError>>> + 'a {
        self.list_namespace_pages(auth_header, project_id, commit_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.entries
                        .into_iter()
                        .map(Ok::<_, CallError<CatalogError>>),
                )
            })
            .try_flatten()
    }
    /// List the live tags of the project in order of name. When a tag is created during a listing
    /// at a name before the current page, the listing does not include it. You must have permission
    /// to list tags.
    pub async fn list_tags_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ListTagsRequest,
    ) -> Result<ListTagsResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("tags");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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_tags_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ListTagsRequest,
    ) -> impl Stream<Item = Result<ListTagsResponse, CallError<CatalogError>>> + '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_tags_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.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::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_tags_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ListTagsRequest,
    ) -> impl Stream<Item = Result<Tag, CallError<CatalogError>>> + 'a {
        self.list_tags_pages(auth_header, project_id, request)
            .map_ok(|page| {
                stream::iter(page.tags.into_iter().map(Ok::<_, CallError<CatalogError>>))
            })
            .try_flatten()
    }
    /// Do a three-way merge, or examine a merge before you do it. When `dryRun` is true, the merge
    /// is not published. Conflicts are part of the response. You must have permission to merge in
    /// the project and to change each resource that the merge changes.
    pub async fn merge_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: MergeRequest,
    ) -> Result<MergeResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("merges");
        }
        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"))
    }
    /// Return all best common ancestors of two commits. When the history has more than one best
    /// common ancestor, the response contains all of them. An empty list means that the histories
    /// are not related. You must have permission to read the project.
    pub async fn merge_bases_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: MergeBasesRequest,
    ) -> Result<MergeBasesResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            path.push("merge-bases");
        }
        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"))
    }
    /// Publish a set of resource and namespace changes as one atomic commit. When an expected
    /// version or binding does not agree with the current state, nothing is published and the
    /// response contains the conflicts. A request that contains only assertions records a commit
    /// but does not change the project state. You must have permission to publish to the project
    /// and to change each resource.
    pub async fn publish_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: PublishRequest,
    ) -> Result<PublishResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("publications");
        }
        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"))
    }
    /// Publish changes and save an operation receipt in one atomic step. When a receipt already
    /// exists for the same project operation and input, the response contains that receipt. The
    /// saved receipt applies to all later requests, from all callers. Each request is authenticated
    /// and authorized again. You must have permission to publish to the project and to change each
    /// resource.
    pub async fn publish_operation_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: PublishOperationRequest,
    ) -> Result<PublishOperationResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("operations");
            path.push("publish");
        }
        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"))
    }
    /// Read a live branch by its name. The response contains the current head commit of the branch.
    /// Use this commit identity with the operations that read one commit. You must have permission
    /// to read the project.
    pub async fn read_branch_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
            path.push("by-name");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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"))
    }
    /// Read one immutable branch event. You must have permission to read the branch history of the
    /// project.
    pub async fn read_branch_event_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        event_id: BranchEventId,
    ) -> Result<BranchEvent, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branch-events");
            let segment = event_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::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"))
    }
    /// List the events of one branch, newest first. This operation also works for a deleted branch.
    /// The first page sets the newest event of the listing. You must have permission to read the
    /// branch history of the project.
    pub async fn read_branch_events_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: ReadRefEventsRequest,
    ) -> Result<BranchEventPage, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
            let segment = branch_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("events");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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 read_branch_events_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: ReadRefEventsRequest,
    ) -> impl Stream<Item = Result<BranchEventPage, CallError<CatalogError>>> + '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();
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let branch_id = branch_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .read_branch_events_http(
                        auth_header.clone(),
                        project_id,
                        branch_id,
                        request.clone(),
                    )
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::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 read_branch_events_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: ReadRefEventsRequest,
    ) -> impl Stream<Item = Result<BranchEvent, CallError<CatalogError>>> + 'a {
        self.read_branch_events_pages(auth_header, project_id, branch_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.events
                        .into_iter()
                        .map(Ok::<_, CallError<CatalogError>>),
                )
            })
            .try_flatten()
    }
    /// Read one immutable commit. You must have permission to read the commits of the project.
    pub async fn read_commit_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
    ) -> Result<Commit, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::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 a part of the commit graph, starting from the commits in `starts`. You must supply
    /// `starts`. To start from branch heads, list the branches first. To read more of the graph,
    /// send `continuationCommitIds` from the response as `starts` in a new request, with the same
    /// exclusions. The next response can contain commits that you already have; ignore them. A
    /// response contains at most 1000 commits. You must have permission to read the commit log of
    /// the project.
    pub async fn read_commit_log_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadCommitLogRequest,
    ) -> Result<CommitLog, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            path.push("log");
        }
        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"))
    }
    /// Read a saved operation receipt. A receipt can contain sensitive project data. An operation
    /// identity does not give access to the receipt. You must have permission to publish to the
    /// project.
    pub async fn read_operation_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        operation_id: OperationId,
    ) -> Result<ReadOperationResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("operations");
            let segment = operation_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::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"))
    }
    /// List the branch events of all branches in the project, in descending order of
    /// `branchEventId`. Event timestamps do not set the order, and identity order is not commit
    /// order. This is a live listing: new events with an identity below the current page can appear
    /// in later pages. Events above the current page do not appear again. You must have permission
    /// to read the branch history of the project.
    pub async fn read_ref_events_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadRefEventsRequest,
    ) -> Result<RefEventPage, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("ref-events");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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 read_ref_events_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ReadRefEventsRequest,
    ) -> impl Stream<Item = Result<RefEventPage, CallError<CatalogError>>> + '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
                    .read_ref_events_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.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::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 read_ref_events_items<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        request: ReadRefEventsRequest,
    ) -> impl Stream<Item = Result<BranchEvent, CallError<CatalogError>>> + 'a {
        self.read_ref_events_pages(auth_header, project_id, request)
            .map_ok(|page| {
                stream::iter(
                    page.events
                        .into_iter()
                        .map(Ok::<_, CallError<CatalogError>>),
                )
            })
            .try_flatten()
    }
    /// Read the identity and version of a resource at one immutable commit. When the commit does
    /// not exist, the response is `CommitNotFound`. When the resource is not live at the commit,
    /// the response is `ResourceNotFound`. You must have permission to read the project state.
    pub async fn read_resource_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        resource_id: ResourceId,
    ) -> Result<ResourceState, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("resources");
            let segment = resource_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::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 resources and namespace bindings of the project at one immutable commit, one page
    /// at a time. You must have permission to read the project state.
    pub async fn read_state_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ReadStateRequest,
    ) -> Result<StatePage, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("state");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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 read_state_pages<'a>(
        &'a self,
        auth_header: &'a AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ReadStateRequest,
    ) -> impl Stream<Item = Result<StatePage, CallError<CatalogError>>> + '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();
            #[allow(
                clippy::clone_on_copy,
                reason = "Hosts may implement Copy for generated aliases; pagination also supports Clone aliases."
            )]
            let commit_id = commit_id.clone();
            async move {
                let Some(mut request) = request else {
                    return Ok(None);
                };
                let page = self
                    .read_state_http(auth_header.clone(), project_id, commit_id, request.clone())
                    .await?;
                let next = page.next_page_token.clone();
                if next.as_ref().is_some_and(|token| {
                    token.0.is_empty() || Some(token) == request.page_token.as_ref()
                }) {
                    return Err(CallError::<CatalogError>::protocol(
                        "invalid pagination token",
                    ));
                }
                request.page_token = next;
                let next_request = request.page_token.is_some().then_some(request);
                Ok(Some((page, next_request)))
            }
        })
    }
    /// Read one immutable tag by its name. Send the name as a query parameter. A name can contain
    /// slashes. You must have permission to read the project.
    pub async fn read_tag_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadTagRequest,
    ) -> Result<Tag, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("tags");
            path.push("by-name");
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder.query(&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"))
    }
    /// Find the result of a publication when you do not know if it completed. Send the transaction
    /// identity of the publication. The search uses the project and the authenticated caller. When
    /// the response has no publication, the publication can still complete later. Thus, when you
    /// retry, use the same transaction identity and idempotency key. You must have permission to
    /// recover publications in the project.
    pub async fn recover_publication_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: RecoverPublicationRequest,
    ) -> Result<RecoverPublicationResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("publications");
            path.push("recover");
        }
        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"))
    }
    /// Change the name of a live branch. The branch keeps its identity and its head commit. The
    /// rename adds an event to the branch history. You must have permission to rename branches.
    pub async fn rename_branch_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: RenameBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("branches");
            let segment = branch_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("rename");
        }
        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"))
    }
    /// Resolve a commit, branch, or tag selector to one commit. The selector is resolved one time.
    /// Relative expressions such as `main~3` are not supported. You must have permission to read
    /// the project.
    pub async fn resolve_commit_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ResolveCommitRequest,
    ) -> Result<ResolveCommitResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            path.push("resolve");
        }
        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"))
    }
    /// Find the resource that a namespace path refers to at one immutable commit. When no resource
    /// has the path, the response has no resource. You must have permission to read the project
    /// state.
    pub async fn resolve_path_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ResolvePathRequest,
    ) -> Result<ResolvePathResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("namespace");
            path.push("resolve");
        }
        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"))
    }
    /// Resolve a batch of namespace paths at one immutable commit. The response has one result for
    /// each path in the request. A request can have at most 1000 paths. You must have permission to
    /// read the project state.
    pub async fn resolve_paths_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ResolvePathsRequest,
    ) -> Result<ResolvePathsResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("commits");
            let segment = commit_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("namespace");
            path.push("resolve-batch");
        }
        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"))
    }
    /// Publish a commit that reverses the changes of a commit, or examine the revert before you do
    /// it. To revert a merge commit, you must supply `mainlineParent`. The value 1 selects the
    /// first parent. When `dryRun` is true, the revert is not published. Conflicts are part of the
    /// response. You must have permission to revert in the project and to change each resource that
    /// the revert changes.
    pub async fn revert_http(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: RevertRequest,
    ) -> Result<RevertResponse, CallError<CatalogError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<CatalogError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("catalog");
            path.push("projects");
            let segment = project_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<CatalogError>::protocol("dot path segment"));
            }
            path.push(&segment);
            path.push("reverts");
        }
        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"))
    }
    async fn send(
        &self,
        builder: reqwest_middleware::RequestBuilder,
        expected_media: &str,
    ) -> Result<reqwest::Response, CallError<CatalogError>> {
        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::<CatalogError>(
                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<CatalogError>> {
    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 CatalogApi for CatalogClient {
    async fn compare_commits(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CompareCommitsRequest,
    ) -> Result<CompareCommitsResponse, CallError<CatalogError>> {
        let response = Self::compare_commits_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn create_branch(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CreateBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let response = Self::create_branch_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn create_tag(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: CreateTagRequest,
    ) -> Result<Tag, CallError<CatalogError>> {
        let response = Self::create_tag_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn delete_branch(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: DeleteBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let response =
            Self::delete_branch_http(self, auth_header, project_id, branch_id, request).await?;
        Ok(response)
    }
    async fn diff_state(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: DiffStateRequest,
    ) -> Result<DiffStateResponse, CallError<CatalogError>> {
        let response = Self::diff_state_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn initialize(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
    ) -> Result<Branch, CallError<CatalogError>> {
        let response = Self::initialize_http(self, auth_header, project_id).await?;
        Ok(response)
    }
    async fn list_branches(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ListBranchesRequest,
    ) -> Result<ListBranchesResponse, CallError<CatalogError>> {
        let response = Self::list_branches_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn list_namespace(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ListNamespaceRequest,
    ) -> Result<NamespacePage, CallError<CatalogError>> {
        let response =
            Self::list_namespace_http(self, auth_header, project_id, commit_id, request).await?;
        Ok(response)
    }
    async fn list_tags(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ListTagsRequest,
    ) -> Result<ListTagsResponse, CallError<CatalogError>> {
        let response = Self::list_tags_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn merge(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: MergeRequest,
    ) -> Result<MergeResponse, CallError<CatalogError>> {
        let response = Self::merge_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn merge_bases(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: MergeBasesRequest,
    ) -> Result<MergeBasesResponse, CallError<CatalogError>> {
        let response = Self::merge_bases_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn publish(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: PublishRequest,
    ) -> Result<PublishResponse, CallError<CatalogError>> {
        let response = Self::publish_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn publish_operation(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: PublishOperationRequest,
    ) -> Result<PublishOperationResponse, CallError<CatalogError>> {
        let response = Self::publish_operation_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn read_branch(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let response = Self::read_branch_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn read_branch_event(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        event_id: BranchEventId,
    ) -> Result<BranchEvent, CallError<CatalogError>> {
        let response =
            Self::read_branch_event_http(self, auth_header, project_id, event_id).await?;
        Ok(response)
    }
    async fn read_branch_events(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: ReadRefEventsRequest,
    ) -> Result<BranchEventPage, CallError<CatalogError>> {
        let response =
            Self::read_branch_events_http(self, auth_header, project_id, branch_id, request)
                .await?;
        Ok(response)
    }
    async fn read_commit(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
    ) -> Result<Commit, CallError<CatalogError>> {
        let response = Self::read_commit_http(self, auth_header, project_id, commit_id).await?;
        Ok(response)
    }
    async fn read_commit_log(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadCommitLogRequest,
    ) -> Result<CommitLog, CallError<CatalogError>> {
        let response = Self::read_commit_log_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn read_operation(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        operation_id: OperationId,
    ) -> Result<ReadOperationResponse, CallError<CatalogError>> {
        let response =
            Self::read_operation_http(self, auth_header, project_id, operation_id).await?;
        Ok(response)
    }
    async fn read_ref_events(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadRefEventsRequest,
    ) -> Result<RefEventPage, CallError<CatalogError>> {
        let response = Self::read_ref_events_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn read_resource(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        resource_id: ResourceId,
    ) -> Result<ResourceState, CallError<CatalogError>> {
        let response =
            Self::read_resource_http(self, auth_header, project_id, commit_id, resource_id).await?;
        Ok(response)
    }
    async fn read_state(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ReadStateRequest,
    ) -> Result<StatePage, CallError<CatalogError>> {
        let response =
            Self::read_state_http(self, auth_header, project_id, commit_id, request).await?;
        Ok(response)
    }
    async fn read_tag(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ReadTagRequest,
    ) -> Result<Tag, CallError<CatalogError>> {
        let response = Self::read_tag_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn recover_publication(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: RecoverPublicationRequest,
    ) -> Result<RecoverPublicationResponse, CallError<CatalogError>> {
        let response =
            Self::recover_publication_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn rename_branch(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        branch_id: BranchId,
        request: RenameBranchRequest,
    ) -> Result<Branch, CallError<CatalogError>> {
        let response =
            Self::rename_branch_http(self, auth_header, project_id, branch_id, request).await?;
        Ok(response)
    }
    async fn resolve_commit(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: ResolveCommitRequest,
    ) -> Result<ResolveCommitResponse, CallError<CatalogError>> {
        let response = Self::resolve_commit_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
    async fn resolve_path(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ResolvePathRequest,
    ) -> Result<ResolvePathResponse, CallError<CatalogError>> {
        let response =
            Self::resolve_path_http(self, auth_header, project_id, commit_id, request).await?;
        Ok(response)
    }
    async fn resolve_paths(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        commit_id: CommitId,
        request: ResolvePathsRequest,
    ) -> Result<ResolvePathsResponse, CallError<CatalogError>> {
        let response =
            Self::resolve_paths_http(self, auth_header, project_id, commit_id, request).await?;
        Ok(response)
    }
    async fn revert(
        &self,
        auth_header: AuthHeader,
        project_id: ProjectId,
        request: RevertRequest,
    ) -> Result<RevertResponse, CallError<CatalogError>> {
        let response = Self::revert_http(self, auth_header, project_id, request).await?;
        Ok(response)
    }
}