roctogen/endpoints/

git.rs

//! Method, error and parameter types for the Git endpoint.
#![allow(
    clippy::all
)]
/* 
 * GitHub v3 REST API
 *
 * GitHub's v3 REST API.
 *
 * OpenAPI spec version: 1.1.4
 * 
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 */

use serde::Deserialize;

use roctokit::adapters::{AdapterError, Client, GitHubRequest, GitHubResponseExt};
use crate::models::*;

use super::PerPage;

use std::collections::HashMap;
use serde_json::value::Value;

pub struct Git<'api, C: Client> where AdapterError: From<<C as Client>::Err> {
    client: &'api C
}

pub fn new<C: Client>(client: &C) -> Git<C> where AdapterError: From<<C as Client>::Err> {
    Git { client }
}

/// Errors for the [Create a blob](Git::create_blob_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitCreateBlobError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Validation failed")]
    Status422(PostGitCreateBlobResponse422),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitCreateBlobError> for AdapterError {
    fn from(err: GitCreateBlobError) -> Self {
        let (description, status_code) = match err {
            GitCreateBlobError::Status404(_) => (String::from("Resource not found"), 404),
            GitCreateBlobError::Status409(_) => (String::from("Conflict"), 409),
            GitCreateBlobError::Status403(_) => (String::from("Forbidden"), 403),
            GitCreateBlobError::Status422(_) => (String::from("Validation failed"), 422),
            GitCreateBlobError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Create a commit](Git::create_commit_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitCreateCommitError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitCreateCommitError> for AdapterError {
    fn from(err: GitCreateCommitError) -> Self {
        let (description, status_code) = match err {
            GitCreateCommitError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitCreateCommitError::Status404(_) => (String::from("Resource not found"), 404),
            GitCreateCommitError::Status409(_) => (String::from("Conflict"), 409),
            GitCreateCommitError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Create a reference](Git::create_ref_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitCreateRefError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitCreateRefError> for AdapterError {
    fn from(err: GitCreateRefError) -> Self {
        let (description, status_code) = match err {
            GitCreateRefError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitCreateRefError::Status409(_) => (String::from("Conflict"), 409),
            GitCreateRefError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Create a tag object](Git::create_tag_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitCreateTagError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitCreateTagError> for AdapterError {
    fn from(err: GitCreateTagError) -> Self {
        let (description, status_code) = match err {
            GitCreateTagError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitCreateTagError::Status409(_) => (String::from("Conflict"), 409),
            GitCreateTagError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Create a tree](Git::create_tree_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitCreateTreeError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitCreateTreeError> for AdapterError {
    fn from(err: GitCreateTreeError) -> Self {
        let (description, status_code) = match err {
            GitCreateTreeError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitCreateTreeError::Status404(_) => (String::from("Resource not found"), 404),
            GitCreateTreeError::Status403(_) => (String::from("Forbidden"), 403),
            GitCreateTreeError::Status409(_) => (String::from("Conflict"), 409),
            GitCreateTreeError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Delete a reference](Git::delete_ref_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitDeleteRefError {
    #[error("Validation failed, an attempt was made to delete the default branch, or the endpoint has been spammed.")]
    Status422,
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitDeleteRefError> for AdapterError {
    fn from(err: GitDeleteRefError) -> Self {
        let (description, status_code) = match err {
            GitDeleteRefError::Status422 => (String::from("Validation failed, an attempt was made to delete the default branch, or the endpoint has been spammed."), 422),
            GitDeleteRefError::Status409(_) => (String::from("Conflict"), 409),
            GitDeleteRefError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Get a blob](Git::get_blob_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitGetBlobError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitGetBlobError> for AdapterError {
    fn from(err: GitGetBlobError) -> Self {
        let (description, status_code) = match err {
            GitGetBlobError::Status404(_) => (String::from("Resource not found"), 404),
            GitGetBlobError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitGetBlobError::Status403(_) => (String::from("Forbidden"), 403),
            GitGetBlobError::Status409(_) => (String::from("Conflict"), 409),
            GitGetBlobError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Get a commit object](Git::get_commit_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitGetCommitError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitGetCommitError> for AdapterError {
    fn from(err: GitGetCommitError) -> Self {
        let (description, status_code) = match err {
            GitGetCommitError::Status404(_) => (String::from("Resource not found"), 404),
            GitGetCommitError::Status409(_) => (String::from("Conflict"), 409),
            GitGetCommitError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Get a reference](Git::get_ref_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitGetRefError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitGetRefError> for AdapterError {
    fn from(err: GitGetRefError) -> Self {
        let (description, status_code) = match err {
            GitGetRefError::Status404(_) => (String::from("Resource not found"), 404),
            GitGetRefError::Status409(_) => (String::from("Conflict"), 409),
            GitGetRefError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Get a tag](Git::get_tag_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitGetTagError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitGetTagError> for AdapterError {
    fn from(err: GitGetTagError) -> Self {
        let (description, status_code) = match err {
            GitGetTagError::Status404(_) => (String::from("Resource not found"), 404),
            GitGetTagError::Status409(_) => (String::from("Conflict"), 409),
            GitGetTagError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Get a tree](Git::get_tree_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitGetTreeError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitGetTreeError> for AdapterError {
    fn from(err: GitGetTreeError) -> Self {
        let (description, status_code) = match err {
            GitGetTreeError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitGetTreeError::Status404(_) => (String::from("Resource not found"), 404),
            GitGetTreeError::Status409(_) => (String::from("Conflict"), 409),
            GitGetTreeError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [List matching references](Git::list_matching_refs_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitListMatchingRefsError {
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitListMatchingRefsError> for AdapterError {
    fn from(err: GitListMatchingRefsError) -> Self {
        let (description, status_code) = match err {
            GitListMatchingRefsError::Status409(_) => (String::from("Conflict"), 409),
            GitListMatchingRefsError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}

/// Errors for the [Update a reference](Git::update_ref_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum GitUpdateRefError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Conflict")]
    Status409(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<GitUpdateRefError> for AdapterError {
    fn from(err: GitUpdateRefError) -> Self {
        let (description, status_code) = match err {
            GitUpdateRefError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            GitUpdateRefError::Status409(_) => (String::from("Conflict"), 409),
            GitUpdateRefError::Generic { code } => (String::from("Generic"), code)
        };

        Self::Endpoint {
            description,
            status_code,
            source: Some(Box::new(err))
        }
    }
}


/// Query parameters for the [Get a tree](Git::get_tree_async()) endpoint.
#[derive(Default, Serialize)]
pub struct GitGetTreeParams<'req> {
    /// Setting this parameter to any value returns the objects or subtrees referenced by the tree specified in `:tree_sha`. For example, setting `recursive` to any of the following will enable returning objects or subtrees: `0`, `1`, `\"true\"`, and `\"false\"`. Omit this parameter to prevent recursively returning objects or subtrees.
    recursive: Option<&'req str>
}

impl<'req> GitGetTreeParams<'req> {
    pub fn new() -> Self {
        Self::default()
    }

    /// Setting this parameter to any value returns the objects or subtrees referenced by the tree specified in `:tree_sha`. For example, setting `recursive` to any of the following will enable returning objects or subtrees: `0`, `1`, `\"true\"`, and `\"false\"`. Omit this parameter to prevent recursively returning objects or subtrees.
    pub fn recursive(self, recursive: &'req str) -> Self {
        Self {
            recursive: Some(recursive),
        }
    }
}


impl<'api, C: Client> Git<'api, C> where AdapterError: From<<C as Client>::Err> {
    /// ---
    ///
    /// # Create a blob
    ///
    /// [GitHub API docs for create_blob](https://docs.github.com/rest/git/blobs#create-a-blob)
    ///
    /// ---
    pub async fn create_blob_async(&self, owner: &str, repo: &str, body: PostGitCreateBlob) -> Result<ShortBlob, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/blobs", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateBlob>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                404 => Err(GitCreateBlobError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitCreateBlobError::Status409(github_response.to_json_async().await?).into()),
                403 => Err(GitCreateBlobError::Status403(github_response.to_json_async().await?).into()),
                422 => Err(GitCreateBlobError::Status422(github_response.to_json_async().await?).into()),
                code => Err(GitCreateBlobError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a blob
    ///
    /// [GitHub API docs for create_blob](https://docs.github.com/rest/git/blobs#create-a-blob)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_blob(&self, owner: &str, repo: &str, body: PostGitCreateBlob) -> Result<ShortBlob, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/blobs", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateBlob>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                404 => Err(GitCreateBlobError::Status404(github_response.to_json()?).into()),
                409 => Err(GitCreateBlobError::Status409(github_response.to_json()?).into()),
                403 => Err(GitCreateBlobError::Status403(github_response.to_json()?).into()),
                422 => Err(GitCreateBlobError::Status422(github_response.to_json()?).into()),
                code => Err(GitCreateBlobError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a commit
    ///
    /// Creates a new Git [commit object](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects).
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in the table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for create_commit](https://docs.github.com/rest/git/commits#create-a-commit)
    ///
    /// ---
    pub async fn create_commit_async(&self, owner: &str, repo: &str, body: PostGitCreateCommit) -> Result<GitCommit, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/commits", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateCommit>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateCommitError::Status422(github_response.to_json_async().await?).into()),
                404 => Err(GitCreateCommitError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitCreateCommitError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitCreateCommitError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a commit
    ///
    /// Creates a new Git [commit object](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects).
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in the table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for create_commit](https://docs.github.com/rest/git/commits#create-a-commit)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_commit(&self, owner: &str, repo: &str, body: PostGitCreateCommit) -> Result<GitCommit, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/commits", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateCommit>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateCommitError::Status422(github_response.to_json()?).into()),
                404 => Err(GitCreateCommitError::Status404(github_response.to_json()?).into()),
                409 => Err(GitCreateCommitError::Status409(github_response.to_json()?).into()),
                code => Err(GitCreateCommitError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a reference
    ///
    /// Creates a reference for your repository. You are unable to create new references for empty repositories, even if the commit SHA-1 hash used exists. Empty repositories are repositories without branches.
    ///
    /// [GitHub API docs for create_ref](https://docs.github.com/rest/git/refs#create-a-reference)
    ///
    /// ---
    pub async fn create_ref_async(&self, owner: &str, repo: &str, body: PostGitCreateRef) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateRef>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateRefError::Status422(github_response.to_json_async().await?).into()),
                409 => Err(GitCreateRefError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitCreateRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a reference
    ///
    /// Creates a reference for your repository. You are unable to create new references for empty repositories, even if the commit SHA-1 hash used exists. Empty repositories are repositories without branches.
    ///
    /// [GitHub API docs for create_ref](https://docs.github.com/rest/git/refs#create-a-reference)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_ref(&self, owner: &str, repo: &str, body: PostGitCreateRef) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateRef>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateRefError::Status422(github_response.to_json()?).into()),
                409 => Err(GitCreateRefError::Status409(github_response.to_json()?).into()),
                code => Err(GitCreateRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a tag object
    ///
    /// Note that creating a tag object does not create the reference that makes a tag in Git. If you want to create an annotated tag in Git, you have to do this call to create the tag object, and then [create](https://docs.github.com/rest/git/refs#create-a-reference) the `refs/tags/[tag]` reference. If you want to create a lightweight tag, you only have to [create](https://docs.github.com/rest/git/refs#create-a-reference) the tag reference - this call would be unnecessary.
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for create_tag](https://docs.github.com/rest/git/tags#create-a-tag-object)
    ///
    /// ---
    pub async fn create_tag_async(&self, owner: &str, repo: &str, body: PostGitCreateTag) -> Result<GitTag, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/tags", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateTag>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateTagError::Status422(github_response.to_json_async().await?).into()),
                409 => Err(GitCreateTagError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitCreateTagError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a tag object
    ///
    /// Note that creating a tag object does not create the reference that makes a tag in Git. If you want to create an annotated tag in Git, you have to do this call to create the tag object, and then [create](https://docs.github.com/rest/git/refs#create-a-reference) the `refs/tags/[tag]` reference. If you want to create a lightweight tag, you only have to [create](https://docs.github.com/rest/git/refs#create-a-reference) the tag reference - this call would be unnecessary.
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for create_tag](https://docs.github.com/rest/git/tags#create-a-tag-object)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_tag(&self, owner: &str, repo: &str, body: PostGitCreateTag) -> Result<GitTag, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/tags", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateTag>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateTagError::Status422(github_response.to_json()?).into()),
                409 => Err(GitCreateTagError::Status409(github_response.to_json()?).into()),
                code => Err(GitCreateTagError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a tree
    ///
    /// The tree creation API accepts nested entries. If you specify both a tree and a nested path modifying that tree, this endpoint will overwrite the contents of the tree with the new path contents, and create a new tree structure.
    /// 
    /// If you use this endpoint to add, delete, or modify the file contents in a tree, you will need to commit the tree and then update a branch to point to the commit. For more information see "[Create a commit](https://docs.github.com/rest/git/commits#create-a-commit)" and "[Update a reference](https://docs.github.com/rest/git/refs#update-a-reference)."
    /// 
    /// Returns an error if you try to delete a file that does not exist.
    ///
    /// [GitHub API docs for create_tree](https://docs.github.com/rest/git/trees#create-a-tree)
    ///
    /// ---
    pub async fn create_tree_async(&self, owner: &str, repo: &str, body: PostGitCreateTree) -> Result<GitTree, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/trees", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateTree>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateTreeError::Status422(github_response.to_json_async().await?).into()),
                404 => Err(GitCreateTreeError::Status404(github_response.to_json_async().await?).into()),
                403 => Err(GitCreateTreeError::Status403(github_response.to_json_async().await?).into()),
                409 => Err(GitCreateTreeError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitCreateTreeError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a tree
    ///
    /// The tree creation API accepts nested entries. If you specify both a tree and a nested path modifying that tree, this endpoint will overwrite the contents of the tree with the new path contents, and create a new tree structure.
    /// 
    /// If you use this endpoint to add, delete, or modify the file contents in a tree, you will need to commit the tree and then update a branch to point to the commit. For more information see "[Create a commit](https://docs.github.com/rest/git/commits#create-a-commit)" and "[Update a reference](https://docs.github.com/rest/git/refs#update-a-reference)."
    /// 
    /// Returns an error if you try to delete a file that does not exist.
    ///
    /// [GitHub API docs for create_tree](https://docs.github.com/rest/git/trees#create-a-tree)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_tree(&self, owner: &str, repo: &str, body: PostGitCreateTree) -> Result<GitTree, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/trees", super::GITHUB_BASE_API_URL, owner, repo);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostGitCreateTree>(body)?),
            method: "POST",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitCreateTreeError::Status422(github_response.to_json()?).into()),
                404 => Err(GitCreateTreeError::Status404(github_response.to_json()?).into()),
                403 => Err(GitCreateTreeError::Status403(github_response.to_json()?).into()),
                409 => Err(GitCreateTreeError::Status409(github_response.to_json()?).into()),
                code => Err(GitCreateTreeError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a reference
    ///
    /// Deletes the provided reference.
    ///
    /// [GitHub API docs for delete_ref](https://docs.github.com/rest/git/refs#delete-a-reference)
    ///
    /// ---
    pub async fn delete_ref_async(&self, owner: &str, repo: &str, git_ref: &str) -> Result<(), AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "DELETE",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(())
        } else {
            match github_response.status_code() {
                422 => Err(GitDeleteRefError::Status422.into()),
                409 => Err(GitDeleteRefError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitDeleteRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a reference
    ///
    /// Deletes the provided reference.
    ///
    /// [GitHub API docs for delete_ref](https://docs.github.com/rest/git/refs#delete-a-reference)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn delete_ref(&self, owner: &str, repo: &str, git_ref: &str) -> Result<(), AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "DELETE",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(())
        } else {
            match github_response.status_code() {
                422 => Err(GitDeleteRefError::Status422.into()),
                409 => Err(GitDeleteRefError::Status409(github_response.to_json()?).into()),
                code => Err(GitDeleteRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a blob
    ///
    /// The `content` in the response will always be Base64 encoded.
    /// 
    /// This endpoint supports the following custom media types. For more information, see "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)."
    /// 
    /// - **`application/vnd.github.raw+json`**: Returns the raw blob data.
    /// - **`application/vnd.github+json`**: Returns a JSON representation of the blob with `content` as a base64 encoded string. This is the default if no media type is specified.
    /// 
    /// **Note** This endpoint supports blobs up to 100 megabytes in size.
    ///
    /// [GitHub API docs for get_blob](https://docs.github.com/rest/git/blobs#get-a-blob)
    ///
    /// ---
    pub async fn get_blob_async(&self, owner: &str, repo: &str, file_sha: &str) -> Result<Blob, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/blobs/{}", super::GITHUB_BASE_API_URL, owner, repo, file_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetBlobError::Status404(github_response.to_json_async().await?).into()),
                422 => Err(GitGetBlobError::Status422(github_response.to_json_async().await?).into()),
                403 => Err(GitGetBlobError::Status403(github_response.to_json_async().await?).into()),
                409 => Err(GitGetBlobError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitGetBlobError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a blob
    ///
    /// The `content` in the response will always be Base64 encoded.
    /// 
    /// This endpoint supports the following custom media types. For more information, see "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)."
    /// 
    /// - **`application/vnd.github.raw+json`**: Returns the raw blob data.
    /// - **`application/vnd.github+json`**: Returns a JSON representation of the blob with `content` as a base64 encoded string. This is the default if no media type is specified.
    /// 
    /// **Note** This endpoint supports blobs up to 100 megabytes in size.
    ///
    /// [GitHub API docs for get_blob](https://docs.github.com/rest/git/blobs#get-a-blob)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_blob(&self, owner: &str, repo: &str, file_sha: &str) -> Result<Blob, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/blobs/{}", super::GITHUB_BASE_API_URL, owner, repo, file_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetBlobError::Status404(github_response.to_json()?).into()),
                422 => Err(GitGetBlobError::Status422(github_response.to_json()?).into()),
                403 => Err(GitGetBlobError::Status403(github_response.to_json()?).into()),
                409 => Err(GitGetBlobError::Status409(github_response.to_json()?).into()),
                code => Err(GitGetBlobError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a commit object
    ///
    /// Gets a Git [commit object](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects).
    /// 
    /// To get the contents of a commit, see "[Get a commit](/rest/commits/commits#get-a-commit)."
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in the table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for get_commit](https://docs.github.com/rest/git/commits#get-a-commit-object)
    ///
    /// ---
    pub async fn get_commit_async(&self, owner: &str, repo: &str, commit_sha: &str) -> Result<GitCommit, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/commits/{}", super::GITHUB_BASE_API_URL, owner, repo, commit_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetCommitError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitGetCommitError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitGetCommitError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a commit object
    ///
    /// Gets a Git [commit object](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects).
    /// 
    /// To get the contents of a commit, see "[Get a commit](/rest/commits/commits#get-a-commit)."
    /// 
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in the table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for get_commit](https://docs.github.com/rest/git/commits#get-a-commit-object)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_commit(&self, owner: &str, repo: &str, commit_sha: &str) -> Result<GitCommit, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/commits/{}", super::GITHUB_BASE_API_URL, owner, repo, commit_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetCommitError::Status404(github_response.to_json()?).into()),
                409 => Err(GitGetCommitError::Status409(github_response.to_json()?).into()),
                code => Err(GitGetCommitError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a reference
    ///
    /// Returns a single reference from your Git database. The `:ref` in the URL must be formatted as `heads/<branch name>` for branches and `tags/<tag name>` for tags. If the `:ref` doesn't match an existing ref, a `404` is returned.
    /// 
    /// > [!NOTE]
    /// > You need to explicitly [request a pull request](https://docs.github.com/rest/pulls/pulls#get-a-pull-request) to trigger a test merge commit, which checks the mergeability of pull requests. For more information, see "[Checking mergeability of pull requests](https://docs.github.com/rest/guides/getting-started-with-the-git-database-api#checking-mergeability-of-pull-requests)".
    ///
    /// [GitHub API docs for get_ref](https://docs.github.com/rest/git/refs#get-a-reference)
    ///
    /// ---
    pub async fn get_ref_async(&self, owner: &str, repo: &str, git_ref: &str) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/ref/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetRefError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitGetRefError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitGetRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a reference
    ///
    /// Returns a single reference from your Git database. The `:ref` in the URL must be formatted as `heads/<branch name>` for branches and `tags/<tag name>` for tags. If the `:ref` doesn't match an existing ref, a `404` is returned.
    /// 
    /// > [!NOTE]
    /// > You need to explicitly [request a pull request](https://docs.github.com/rest/pulls/pulls#get-a-pull-request) to trigger a test merge commit, which checks the mergeability of pull requests. For more information, see "[Checking mergeability of pull requests](https://docs.github.com/rest/guides/getting-started-with-the-git-database-api#checking-mergeability-of-pull-requests)".
    ///
    /// [GitHub API docs for get_ref](https://docs.github.com/rest/git/refs#get-a-reference)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_ref(&self, owner: &str, repo: &str, git_ref: &str) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/ref/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetRefError::Status404(github_response.to_json()?).into()),
                409 => Err(GitGetRefError::Status409(github_response.to_json()?).into()),
                code => Err(GitGetRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a tag
    ///
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for get_tag](https://docs.github.com/rest/git/tags#get-a-tag)
    ///
    /// ---
    pub async fn get_tag_async(&self, owner: &str, repo: &str, tag_sha: &str) -> Result<GitTag, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/tags/{}", super::GITHUB_BASE_API_URL, owner, repo, tag_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetTagError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitGetTagError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitGetTagError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a tag
    ///
    /// **Signature verification object**
    /// 
    /// The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
    /// 
    /// | Name | Type | Description |
    /// | ---- | ---- | ----------- |
    /// | `verified` | `boolean` | Indicates whether GitHub considers the signature in this commit to be verified. |
    /// | `reason` | `string` | The reason for verified value. Possible values and their meanings are enumerated in table below. |
    /// | `signature` | `string` | The signature that was extracted from the commit. |
    /// | `payload` | `string` | The value that was signed. |
    /// | `verified_at` | `string` | The date the signature was verified by GitHub. |
    /// 
    /// These are the possible values for `reason` in the `verification` object:
    /// 
    /// | Value | Description |
    /// | ----- | ----------- |
    /// | `expired_key` | The key that made the signature is expired. |
    /// | `not_signing_key` | The "signing" flag is not among the usage flags in the GPG key that made the signature. |
    /// | `gpgverify_error` | There was an error communicating with the signature verification service. |
    /// | `gpgverify_unavailable` | The signature verification service is currently unavailable. |
    /// | `unsigned` | The object does not include a signature. |
    /// | `unknown_signature_type` | A non-PGP signature was found in the commit. |
    /// | `no_user` | No user was associated with the `committer` email address in the commit. |
    /// | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
    /// | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
    /// | `unknown_key` | The key that made the signature has not been registered with any user's account. |
    /// | `malformed_signature` | There was an error parsing the signature. |
    /// | `invalid` | The signature could not be cryptographically verified using the key whose key-id was found in the signature. |
    /// | `valid` | None of the above errors applied, so the signature is considered to be verified. |
    ///
    /// [GitHub API docs for get_tag](https://docs.github.com/rest/git/tags#get-a-tag)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_tag(&self, owner: &str, repo: &str, tag_sha: &str) -> Result<GitTag, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/tags/{}", super::GITHUB_BASE_API_URL, owner, repo, tag_sha);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                404 => Err(GitGetTagError::Status404(github_response.to_json()?).into()),
                409 => Err(GitGetTagError::Status409(github_response.to_json()?).into()),
                code => Err(GitGetTagError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a tree
    ///
    /// Returns a single tree using the SHA1 value or ref name for that tree.
    /// 
    /// If `truncated` is `true` in the response then the number of items in the `tree` array exceeded our maximum limit. If you need to fetch more items, use the non-recursive method of fetching trees, and fetch one sub-tree at a time.
    /// 
    /// > [!NOTE]
    /// > The limit for the `tree` array is 100,000 entries with a maximum size of 7 MB when using the `recursive` parameter.
    ///
    /// [GitHub API docs for get_tree](https://docs.github.com/rest/git/trees#get-a-tree)
    ///
    /// ---
    pub async fn get_tree_async(&self, owner: &str, repo: &str, tree_sha: &str, query_params: Option<impl Into<GitGetTreeParams<'api>>>) -> Result<GitTree, AdapterError> {

        let mut request_uri = format!("{}/repos/{}/{}/git/trees/{}", super::GITHUB_BASE_API_URL, owner, repo, tree_sha);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            request_uri.push_str(&serde_urlencoded::to_string(params.into())?);
        }

        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitGetTreeError::Status422(github_response.to_json_async().await?).into()),
                404 => Err(GitGetTreeError::Status404(github_response.to_json_async().await?).into()),
                409 => Err(GitGetTreeError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitGetTreeError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a tree
    ///
    /// Returns a single tree using the SHA1 value or ref name for that tree.
    /// 
    /// If `truncated` is `true` in the response then the number of items in the `tree` array exceeded our maximum limit. If you need to fetch more items, use the non-recursive method of fetching trees, and fetch one sub-tree at a time.
    /// 
    /// > [!NOTE]
    /// > The limit for the `tree` array is 100,000 entries with a maximum size of 7 MB when using the `recursive` parameter.
    ///
    /// [GitHub API docs for get_tree](https://docs.github.com/rest/git/trees#get-a-tree)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_tree(&self, owner: &str, repo: &str, tree_sha: &str, query_params: Option<impl Into<GitGetTreeParams<'api>>>) -> Result<GitTree, AdapterError> {

        let mut request_uri = format!("{}/repos/{}/{}/git/trees/{}", super::GITHUB_BASE_API_URL, owner, repo, tree_sha);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: GitGetTreeParams = params.into();
            request_uri.push_str(&serde_urlencoded::to_string(qp)?);
        }

        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitGetTreeError::Status422(github_response.to_json()?).into()),
                404 => Err(GitGetTreeError::Status404(github_response.to_json()?).into()),
                409 => Err(GitGetTreeError::Status409(github_response.to_json()?).into()),
                code => Err(GitGetTreeError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List matching references
    ///
    /// Returns an array of references from your Git database that match the supplied name. The `:ref` in the URL must be formatted as `heads/<branch name>` for branches and `tags/<tag name>` for tags. If the `:ref` doesn't exist in the repository, but existing refs start with `:ref`, they will be returned as an array.
    /// 
    /// When you use this endpoint without providing a `:ref`, it will return an array of all the references from your Git database, including notes and stashes if they exist on the server. Anything in the namespace is returned, not just `heads` and `tags`.
    /// 
    /// > [!NOTE]
    /// > You need to explicitly [request a pull request](https://docs.github.com/rest/pulls/pulls#get-a-pull-request) to trigger a test merge commit, which checks the mergeability of pull requests. For more information, see "[Checking mergeability of pull requests](https://docs.github.com/rest/guides/getting-started-with-the-git-database-api#checking-mergeability-of-pull-requests)".
    /// 
    /// If you request matching references for a branch named `feature` but the branch `feature` doesn't exist, the response can still include other matching head refs that start with the word `feature`, such as `featureA` and `featureB`.
    ///
    /// [GitHub API docs for list_matching_refs](https://docs.github.com/rest/git/refs#list-matching-references)
    ///
    /// ---
    pub async fn list_matching_refs_async(&self, owner: &str, repo: &str, git_ref: &str) -> Result<Vec<GitRef>, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/matching-refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None::<C::Body>,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                409 => Err(GitListMatchingRefsError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitListMatchingRefsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List matching references
    ///
    /// Returns an array of references from your Git database that match the supplied name. The `:ref` in the URL must be formatted as `heads/<branch name>` for branches and `tags/<tag name>` for tags. If the `:ref` doesn't exist in the repository, but existing refs start with `:ref`, they will be returned as an array.
    /// 
    /// When you use this endpoint without providing a `:ref`, it will return an array of all the references from your Git database, including notes and stashes if they exist on the server. Anything in the namespace is returned, not just `heads` and `tags`.
    /// 
    /// > [!NOTE]
    /// > You need to explicitly [request a pull request](https://docs.github.com/rest/pulls/pulls#get-a-pull-request) to trigger a test merge commit, which checks the mergeability of pull requests. For more information, see "[Checking mergeability of pull requests](https://docs.github.com/rest/guides/getting-started-with-the-git-database-api#checking-mergeability-of-pull-requests)".
    /// 
    /// If you request matching references for a branch named `feature` but the branch `feature` doesn't exist, the response can still include other matching head refs that start with the word `feature`, such as `featureA` and `featureB`.
    ///
    /// [GitHub API docs for list_matching_refs](https://docs.github.com/rest/git/refs#list-matching-references)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_matching_refs(&self, owner: &str, repo: &str, git_ref: &str) -> Result<Vec<GitRef>, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/matching-refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: None,
            method: "GET",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                409 => Err(GitListMatchingRefsError::Status409(github_response.to_json()?).into()),
                code => Err(GitListMatchingRefsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update a reference
    ///
    /// Updates the provided reference to point to a new SHA. For more information, see "[Git References](https://git-scm.com/book/en/v2/Git-Internals-Git-References)" in the Git documentation.
    ///
    /// [GitHub API docs for update_ref](https://docs.github.com/rest/git/refs#update-a-reference)
    ///
    /// ---
    pub async fn update_ref_async(&self, owner: &str, repo: &str, git_ref: &str, body: PatchGitUpdateRef) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchGitUpdateRef>(body)?),
            method: "PATCH",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch_async(request).await?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json_async().await?)
        } else {
            match github_response.status_code() {
                422 => Err(GitUpdateRefError::Status422(github_response.to_json_async().await?).into()),
                409 => Err(GitUpdateRefError::Status409(github_response.to_json_async().await?).into()),
                code => Err(GitUpdateRefError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update a reference
    ///
    /// Updates the provided reference to point to a new SHA. For more information, see "[Git References](https://git-scm.com/book/en/v2/Git-Internals-Git-References)" in the Git documentation.
    ///
    /// [GitHub API docs for update_ref](https://docs.github.com/rest/git/refs#update-a-reference)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn update_ref(&self, owner: &str, repo: &str, git_ref: &str, body: PatchGitUpdateRef) -> Result<GitRef, AdapterError> {

        let request_uri = format!("{}/repos/{}/{}/git/refs/{}", super::GITHUB_BASE_API_URL, owner, repo, git_ref);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchGitUpdateRef>(body)?),
            method: "PATCH",
            headers: vec![]
        };

        let request = self.client.build(req)?;

        // --

        let github_response = self.client.fetch(request)?;

        // --

        if github_response.is_success() {
            Ok(github_response.to_json()?)
        } else {
            match github_response.status_code() {
                422 => Err(GitUpdateRefError::Status422(github_response.to_json()?).into()),
                409 => Err(GitUpdateRefError::Status409(github_response.to_json()?).into()),
                code => Err(GitUpdateRefError::Generic { code }.into()),
            }
        }
    }

}