gitverse_sdk/

repositories.rs

// Code generated by gitverse-codegen. DO NOT EDIT.

use crate::client::{Client, decode_response, handle_empty_response};
use crate::errors::Error;
use crate::types::*;

impl Client {
    /// Get repository details
    pub async fn get(&self, owner: &str, repo: &str) -> Result<Repository, Error> {
        let path = format!("/repos/{}/{}", owner, repo);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Update repository
    pub async fn update(
        &self,
        owner: &str,
        repo: &str,
        params: &UpdateRepositoryParams,
    ) -> Result<Repository, Error> {
        let path = format!("/repos/{}/{}", owner, repo);
        let resp = self.send_patch(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Delete repository
    pub async fn delete(&self, owner: &str, repo: &str) -> Result<(), Error> {
        let path = format!("/repos/{}/{}", owner, repo);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// Gets a list of repository secrets
    pub async fn list_repo_secrets(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<SecretList, Error> {
        let path = format!("/repos/{}/{}/actions/secrets", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Gets secrets metadata (without values) in repositories.
    pub async fn get_repo_secret(
        &self,
        owner: &str,
        repo: &str,
        secretname: &str,
    ) -> Result<Secret, Error> {
        let path = format!("/repos/{}/{}/actions/secrets/{}", owner, repo, secretname);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Creates or updates a secret in the repository
    pub async fn create_or_update_repo_secret(
        &self,
        owner: &str,
        repo: &str,
        secretname: &str,
        _opts: Option<&QueryOptions>,
    ) -> Result<Secret, Error> {
        let path = format!("/repos/{}/{}/actions/secrets/{}", owner, repo, secretname);
        let resp = self.send_put(&path, Option::<&()>::None).await?;
        decode_response(resp).await
    }

    /// Removes a secret from the repository
    pub async fn delete_repo_secret(
        &self,
        owner: &str,
        repo: &str,
        secretname: &str,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/secrets/{}", owner, repo, secretname);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// List repository branches
    pub async fn list_branches(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<Vec<Branch>, Error> {
        let path = format!("/repos/{}/{}/branches", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// List repository collaborators
    pub async fn list_collaborators(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<Vec<Collaborator>, Error> {
        let path = format!("/repos/{}/{}/collaborators", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Add or update repository collaborator
    pub async fn add_collaborator(
        &self,
        owner: &str,
        repo: &str,
        collaborator: &str,
        params: &AddCollaboratorParams,
    ) -> Result<CollaboratorInvitation, Error> {
        let path = format!("/repos/{}/{}/collaborators/{}", owner, repo, collaborator);
        let resp = self.send_put(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Retrieve a list of repository commits
    pub async fn list_commits(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<Vec<Commit>, Error> {
        let path = format!("/repos/{}/{}/commits", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Retrieve commit information
    pub async fn get_commit(&self, owner: &str, repo: &str, sha: &str) -> Result<Commit, Error> {
        let path = format!("/repos/{}/{}/commits/{}", owner, repo, sha);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Compare two branches/tags/commits
    pub async fn compare_commits(
        &self,
        owner: &str,
        repo: &str,
        basehead: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<CompareResponse, Error> {
        let path = format!("/repos/{}/{}/compare/{}", owner, repo, basehead);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Get file or directory contents
    pub async fn get_content(
        &self,
        owner: &str,
        repo: &str,
        filepath: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<ContentsResponse, Error> {
        let path = format!("/repos/{}/{}/contents/{}", owner, repo, filepath);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Create or update file in repository
    pub async fn create_or_update_file(
        &self,
        owner: &str,
        repo: &str,
        filepath: &str,
        params: &CreateFileParams,
    ) -> Result<FileCreationResponse, Error> {
        let path = format!("/repos/{}/{}/contents/{}", owner, repo, filepath);
        let resp = self.send_put(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Delete file in repository
    pub async fn delete_file(
        &self,
        owner: &str,
        repo: &str,
        filepath: &str,
        params: &DeleteFileParams,
    ) -> Result<FileDeleteResponse, Error> {
        let path = format!("/repos/{}/{}/contents/{}", owner, repo, filepath);
        let resp = self.send_delete(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Fork a repository
    pub async fn create_fork(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateForkParams,
    ) -> Result<Repository, Error> {
        let path = format!("/repos/{}/{}/forks", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Create a Git commit
    pub async fn create_commit(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateCommitParams,
    ) -> Result<Commit, Error> {
        let path = format!("/repos/{}/{}/git/commits", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// List matching references
    pub async fn list_matching_refs(
        &self,
        owner: &str,
        repo: &str,
        r#ref: &str,
    ) -> Result<Vec<Reference>, Error> {
        let path = format!("/repos/{}/{}/git/matching-refs/{}", owner, repo, r#ref);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Get a Git reference
    pub async fn get_ref(&self, owner: &str, repo: &str, r#ref: &str) -> Result<Reference, Error> {
        let path = format!("/repos/{}/{}/git/ref/{}", owner, repo, r#ref);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Create a Git reference
    pub async fn create_ref(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateReferenceParams,
    ) -> Result<Reference, Error> {
        let path = format!("/repos/{}/{}/git/refs", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Deletes the provided reference
    pub async fn delete_ref(&self, owner: &str, repo: &str, r#ref: &str) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/git/refs/{}", owner, repo, r#ref);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// Creates new Git tree
    pub async fn create_tree(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateTreeParams,
    ) -> Result<RepoTree, Error> {
        let path = format!("/repos/{}/{}/git/trees", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Get repository tree by SHA
    pub async fn get_tree(
        &self,
        owner: &str,
        repo: &str,
        sha: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<GitTreeResponse, Error> {
        let path = format!("/repos/{}/{}/git/trees/{}", owner, repo, sha);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Get repository languages
    pub async fn list_languages(
        &self,
        owner: &str,
        repo: &str,
    ) -> Result<serde_json::Value, Error> {
        let path = format!("/repos/{}/{}/languages", owner, repo);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// List pull requests
    pub async fn list_pulls(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<Vec<PullRequest>, Error> {
        let path = format!("/repos/{}/{}/pulls", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Pull request details.
    pub async fn get_pull(
        &self,
        owner: &str,
        repo: &str,
        pull_number: f64,
    ) -> Result<PullRequest, Error> {
        let path = format!("/repos/{}/{}/pulls/{}", owner, repo, pull_number);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Update a pull request.
    pub async fn update_pull(
        &self,
        owner: &str,
        repo: &str,
        pull_number: f64,
        params: &UpdatePullRequestParams,
    ) -> Result<PullRequest, Error> {
        let path = format!("/repos/{}/{}/pulls/{}", owner, repo, pull_number);
        let resp = self.send_patch(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Get authenticated user repositories
    pub async fn list_for_authenticated_user(
        &self,
        opts: Option<&QueryOptions>,
    ) -> Result<Vec<Repository>, Error> {
        let path = "/user/repos";
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Create repository
    pub async fn create_for_authenticated_user(
        &self,
        params: &CreateRepositoryParams,
    ) -> Result<Repository, Error> {
        let path = "/user/repos";
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }
}