roctogen 0.50.0

//! Method, error and parameter types for the ProjectsClassic 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 ProjectsClassic<'api, C: Client> where AdapterError: From<<C as Client>::Err> {
    client: &'api C
}

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

/// Errors for the [Add project collaborator](ProjectsClassic::add_collaborator_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicAddCollaboratorError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicAddCollaboratorError> for AdapterError {
    fn from(err: ProjectsClassicAddCollaboratorError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicAddCollaboratorError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicAddCollaboratorError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicAddCollaboratorError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicAddCollaboratorError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicAddCollaboratorError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicAddCollaboratorError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Create a project card](ProjectsClassic::create_card_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicCreateCardError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Validation failed")]
    Status422(PostProjectsClassicCreateCardResponse422),
    #[error("Response")]
    Status503(PostProjectsClassicCreateCardResponse503),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicCreateCardError> for AdapterError {
    fn from(err: ProjectsClassicCreateCardError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicCreateCardError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicCreateCardError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicCreateCardError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicCreateCardError::Status422(_) => (String::from("Validation failed"), 422),
            ProjectsClassicCreateCardError::Status503(_) => (String::from("Response"), 503),
            ProjectsClassicCreateCardError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Create a project column](ProjectsClassic::create_column_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicCreateColumnError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicCreateColumnError> for AdapterError {
    fn from(err: ProjectsClassicCreateColumnError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicCreateColumnError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicCreateColumnError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicCreateColumnError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicCreateColumnError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicCreateColumnError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Create a user project](ProjectsClassic::create_for_authenticated_user_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicCreateForAuthenticatedUserError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicCreateForAuthenticatedUserError> for AdapterError {
    fn from(err: ProjectsClassicCreateForAuthenticatedUserError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicCreateForAuthenticatedUserError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicCreateForAuthenticatedUserError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicCreateForAuthenticatedUserError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicCreateForAuthenticatedUserError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicCreateForAuthenticatedUserError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Create an organization project](ProjectsClassic::create_for_org_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicCreateForOrgError {
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Gone")]
    Status410(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicCreateForOrgError> for AdapterError {
    fn from(err: ProjectsClassicCreateForOrgError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicCreateForOrgError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicCreateForOrgError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicCreateForOrgError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicCreateForOrgError::Status410(_) => (String::from("Gone"), 410),
            ProjectsClassicCreateForOrgError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicCreateForOrgError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Create a repository project](ProjectsClassic::create_for_repo_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicCreateForRepoError {
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Gone")]
    Status410(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicCreateForRepoError> for AdapterError {
    fn from(err: ProjectsClassicCreateForRepoError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicCreateForRepoError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicCreateForRepoError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicCreateForRepoError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicCreateForRepoError::Status410(_) => (String::from("Gone"), 410),
            ProjectsClassicCreateForRepoError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicCreateForRepoError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Delete a project](ProjectsClassic::delete_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicDeleteError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(PatchProjectsClassicUpdateResponse403),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Gone")]
    Status410(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicDeleteError> for AdapterError {
    fn from(err: ProjectsClassicDeleteError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicDeleteError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicDeleteError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicDeleteError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicDeleteError::Status410(_) => (String::from("Gone"), 410),
            ProjectsClassicDeleteError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicDeleteError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Delete a project card](ProjectsClassic::delete_card_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicDeleteCardError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(PatchProjectsClassicUpdateResponse403),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicDeleteCardError> for AdapterError {
    fn from(err: ProjectsClassicDeleteCardError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicDeleteCardError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicDeleteCardError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicDeleteCardError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicDeleteCardError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicDeleteCardError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Delete a project column](ProjectsClassic::delete_column_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicDeleteColumnError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicDeleteColumnError> for AdapterError {
    fn from(err: ProjectsClassicDeleteColumnError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicDeleteColumnError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicDeleteColumnError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicDeleteColumnError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicDeleteColumnError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Get a project](ProjectsClassic::get_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicGetError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicGetError> for AdapterError {
    fn from(err: ProjectsClassicGetError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicGetError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicGetError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicGetError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicGetError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Get a project card](ProjectsClassic::get_card_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicGetCardError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicGetCardError> for AdapterError {
    fn from(err: ProjectsClassicGetCardError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicGetCardError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicGetCardError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicGetCardError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicGetCardError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicGetCardError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Get a project column](ProjectsClassic::get_column_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicGetColumnError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicGetColumnError> for AdapterError {
    fn from(err: ProjectsClassicGetColumnError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicGetColumnError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicGetColumnError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicGetColumnError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicGetColumnError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicGetColumnError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Get project permission for a user](ProjectsClassic::get_permission_for_user_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicGetPermissionForUserError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicGetPermissionForUserError> for AdapterError {
    fn from(err: ProjectsClassicGetPermissionForUserError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicGetPermissionForUserError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicGetPermissionForUserError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicGetPermissionForUserError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicGetPermissionForUserError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicGetPermissionForUserError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicGetPermissionForUserError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [List project cards](ProjectsClassic::list_cards_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListCardsError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicListCardsError> for AdapterError {
    fn from(err: ProjectsClassicListCardsError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicListCardsError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicListCardsError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicListCardsError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicListCardsError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [List project collaborators](ProjectsClassic::list_collaborators_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListCollaboratorsError {
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicListCollaboratorsError> for AdapterError {
    fn from(err: ProjectsClassicListCollaboratorsError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicListCollaboratorsError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicListCollaboratorsError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicListCollaboratorsError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicListCollaboratorsError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicListCollaboratorsError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicListCollaboratorsError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [List project columns](ProjectsClassic::list_columns_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListColumnsError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicListColumnsError> for AdapterError {
    fn from(err: ProjectsClassicListColumnsError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicListColumnsError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicListColumnsError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicListColumnsError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicListColumnsError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [List organization projects](ProjectsClassic::list_for_org_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListForOrgError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

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

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

/// Errors for the [List repository projects](ProjectsClassic::list_for_repo_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListForRepoError {
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Gone")]
    Status410(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicListForRepoError> for AdapterError {
    fn from(err: ProjectsClassicListForRepoError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicListForRepoError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicListForRepoError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicListForRepoError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicListForRepoError::Status410(_) => (String::from("Gone"), 410),
            ProjectsClassicListForRepoError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicListForRepoError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [List user projects](ProjectsClassic::list_for_user_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicListForUserError {
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

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

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

/// Errors for the [Move a project card](ProjectsClassic::move_card_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicMoveCardError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(PostProjectsClassicMoveCardResponse403),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Response")]
    Status503(PostProjectsClassicCreateCardResponse503),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicMoveCardError> for AdapterError {
    fn from(err: ProjectsClassicMoveCardError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicMoveCardError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicMoveCardError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicMoveCardError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicMoveCardError::Status503(_) => (String::from("Response"), 503),
            ProjectsClassicMoveCardError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicMoveCardError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Move a project column](ProjectsClassic::move_column_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicMoveColumnError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicMoveColumnError> for AdapterError {
    fn from(err: ProjectsClassicMoveColumnError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicMoveColumnError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicMoveColumnError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicMoveColumnError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicMoveColumnError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicMoveColumnError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Remove user as a collaborator](ProjectsClassic::remove_collaborator_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicRemoveCollaboratorError {
    #[error("Not modified")]
    Status304,
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicRemoveCollaboratorError> for AdapterError {
    fn from(err: ProjectsClassicRemoveCollaboratorError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicRemoveCollaboratorError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicRemoveCollaboratorError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicRemoveCollaboratorError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicRemoveCollaboratorError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicRemoveCollaboratorError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicRemoveCollaboratorError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Update a project](ProjectsClassic::update_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicUpdateError {
    #[error("Not Found if the authenticated user does not have access to the project")]
    Status404,
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(PatchProjectsClassicUpdateResponse403),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Gone")]
    Status410(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicUpdateError> for AdapterError {
    fn from(err: ProjectsClassicUpdateError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicUpdateError::Status404 => (String::from("Not Found if the authenticated user does not have access to the project"), 404),
            ProjectsClassicUpdateError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicUpdateError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicUpdateError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicUpdateError::Status410(_) => (String::from("Gone"), 410),
            ProjectsClassicUpdateError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicUpdateError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Update an existing project card](ProjectsClassic::update_card_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicUpdateCardError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Resource not found")]
    Status404(BasicError),
    #[error("Validation failed, or the endpoint has been spammed.")]
    Status422(ValidationErrorSimple),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicUpdateCardError> for AdapterError {
    fn from(err: ProjectsClassicUpdateCardError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicUpdateCardError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicUpdateCardError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicUpdateCardError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicUpdateCardError::Status404(_) => (String::from("Resource not found"), 404),
            ProjectsClassicUpdateCardError::Status422(_) => (String::from("Validation failed, or the endpoint has been spammed."), 422),
            ProjectsClassicUpdateCardError::Generic { code } => (String::from("Generic"), code)
        };

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

/// Errors for the [Update an existing project column](ProjectsClassic::update_column_async()) endpoint.
#[derive(Debug, thiserror::Error)]
pub enum ProjectsClassicUpdateColumnError {
    #[error("Not modified")]
    Status304,
    #[error("Forbidden")]
    Status403(BasicError),
    #[error("Requires authentication")]
    Status401(BasicError),
    #[error("Status code: {}", code)]
    Generic { code: u16 },
}

impl From<ProjectsClassicUpdateColumnError> for AdapterError {
    fn from(err: ProjectsClassicUpdateColumnError) -> Self {
        let (description, status_code) = match err {
            ProjectsClassicUpdateColumnError::Status304 => (String::from("Not modified"), 304),
            ProjectsClassicUpdateColumnError::Status403(_) => (String::from("Forbidden"), 403),
            ProjectsClassicUpdateColumnError::Status401(_) => (String::from("Requires authentication"), 401),
            ProjectsClassicUpdateColumnError::Generic { code } => (String::from("Generic"), code)
        };

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


/// Query parameters for the [List project cards](ProjectsClassic::list_cards_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListCardsParams<'req> {
    /// Filters the project cards that are returned by the card's state.
    archived_state: Option<&'req str>, 
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

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

    /// Filters the project cards that are returned by the card's state.
    pub fn archived_state(self, archived_state: &'req str) -> Self {
        Self {
            archived_state: Some(archived_state),
            per_page: self.per_page, 
            page: self.page, 
        }
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            archived_state: self.archived_state, 
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            archived_state: self.archived_state, 
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListCardsParams<'enc> {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}
/// Query parameters for the [List project collaborators](ProjectsClassic::list_collaborators_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListCollaboratorsParams<'req> {
    /// Filters the collaborators by their affiliation. `outside` means outside collaborators of a project that are not a member of the project's organization. `direct` means collaborators with permissions to a project, regardless of organization membership status. `all` means all collaborators the authenticated user can see.
    affiliation: Option<&'req str>, 
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

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

    /// Filters the collaborators by their affiliation. `outside` means outside collaborators of a project that are not a member of the project's organization. `direct` means collaborators with permissions to a project, regardless of organization membership status. `all` means all collaborators the authenticated user can see.
    pub fn affiliation(self, affiliation: &'req str) -> Self {
        Self {
            affiliation: Some(affiliation),
            per_page: self.per_page, 
            page: self.page, 
        }
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            affiliation: self.affiliation, 
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            affiliation: self.affiliation, 
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListCollaboratorsParams<'enc> {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}
/// Query parameters for the [List project columns](ProjectsClassic::list_columns_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListColumnsParams {
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

impl ProjectsClassicListColumnsParams {
    pub fn new() -> Self {
        Self::default()
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListColumnsParams {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}
/// Query parameters for the [List organization projects](ProjectsClassic::list_for_org_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListForOrgParams<'req> {
    /// Indicates the state of the projects to return.
    state: Option<&'req str>, 
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

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

    /// Indicates the state of the projects to return.
    pub fn state(self, state: &'req str) -> Self {
        Self {
            state: Some(state),
            per_page: self.per_page, 
            page: self.page, 
        }
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListForOrgParams<'enc> {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}
/// Query parameters for the [List repository projects](ProjectsClassic::list_for_repo_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListForRepoParams<'req> {
    /// Indicates the state of the projects to return.
    state: Option<&'req str>, 
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

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

    /// Indicates the state of the projects to return.
    pub fn state(self, state: &'req str) -> Self {
        Self {
            state: Some(state),
            per_page: self.per_page, 
            page: self.page, 
        }
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListForRepoParams<'enc> {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}
/// Query parameters for the [List user projects](ProjectsClassic::list_for_user_async()) endpoint.
#[derive(Default, Serialize)]
pub struct ProjectsClassicListForUserParams<'req> {
    /// Indicates the state of the projects to return.
    state: Option<&'req str>, 
    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    per_page: Option<u16>, 
    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    page: Option<u16>
}

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

    /// Indicates the state of the projects to return.
    pub fn state(self, state: &'req str) -> Self {
        Self {
            state: Some(state),
            per_page: self.per_page, 
            page: self.page, 
        }
    }

    /// The number of results per page (max 100). For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn per_page(self, per_page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: Some(per_page),
            page: self.page, 
        }
    }

    /// The page number of the results to fetch. For more information, see \"[Using pagination in the REST API](https://docs.github.com/rest/using-the-rest-api/using-pagination-in-the-rest-api).\"
    pub fn page(self, page: u16) -> Self {
        Self {
            state: self.state, 
            per_page: self.per_page, 
            page: Some(page),
        }
    }
}

impl<'enc> From<&'enc PerPage> for ProjectsClassicListForUserParams<'enc> {
    fn from(per_page: &'enc PerPage) -> Self {
        Self {
            per_page: Some(per_page.per_page),
            page: Some(per_page.page),
            ..Default::default()
        }
    }
}

impl<'api, C: Client> ProjectsClassic<'api, C> where AdapterError: From<<C as Client>::Err> {
    /// ---
    ///
    /// # Add project collaborator
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for add_collaborator](https://docs.github.com/rest/projects-classic/collaborators#add-project-collaborator)
    ///
    /// ---
    pub async fn add_collaborator_async(&self, project_id: i32, username: &str, body: PutProjectsClassicAddCollaborator) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}", super::GITHUB_BASE_API_URL, project_id, username);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PutProjectsClassicAddCollaborator>(body)?),
            method: "PUT",
            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() {
                404 => Err(ProjectsClassicAddCollaboratorError::Status404(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicAddCollaboratorError::Status422(github_response.to_json_async().await?).into()),
                304 => Err(ProjectsClassicAddCollaboratorError::Status304.into()),
                403 => Err(ProjectsClassicAddCollaboratorError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicAddCollaboratorError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicAddCollaboratorError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Add project collaborator
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for add_collaborator](https://docs.github.com/rest/projects-classic/collaborators#add-project-collaborator)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn add_collaborator(&self, project_id: i32, username: &str, body: PutProjectsClassicAddCollaborator) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}", super::GITHUB_BASE_API_URL, project_id, username);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PutProjectsClassicAddCollaborator>(body)?),
            method: "PUT",
            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() {
                404 => Err(ProjectsClassicAddCollaboratorError::Status404(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicAddCollaboratorError::Status422(github_response.to_json()?).into()),
                304 => Err(ProjectsClassicAddCollaboratorError::Status304.into()),
                403 => Err(ProjectsClassicAddCollaboratorError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicAddCollaboratorError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicAddCollaboratorError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_card](https://docs.github.com/rest/projects-classic/cards#create-a-project-card)
    ///
    /// ---
    pub async fn create_card_async(&self, column_id: i32, body: PostProjectsClassicCreateCard) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}/cards", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateCard>(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() {
                304 => Err(ProjectsClassicCreateCardError::Status304.into()),
                403 => Err(ProjectsClassicCreateCardError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicCreateCardError::Status401(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicCreateCardError::Status422(github_response.to_json_async().await?).into()),
                503 => Err(ProjectsClassicCreateCardError::Status503(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicCreateCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_card](https://docs.github.com/rest/projects-classic/cards#create-a-project-card)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_card(&self, column_id: i32, body: PostProjectsClassicCreateCard) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}/cards", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateCard>(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() {
                304 => Err(ProjectsClassicCreateCardError::Status304.into()),
                403 => Err(ProjectsClassicCreateCardError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicCreateCardError::Status401(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicCreateCardError::Status422(github_response.to_json()?).into()),
                503 => Err(ProjectsClassicCreateCardError::Status503(github_response.to_json()?).into()),
                code => Err(ProjectsClassicCreateCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_column](https://docs.github.com/rest/projects-classic/columns#create-a-project-column)
    ///
    /// ---
    pub async fn create_column_async(&self, project_id: i32, body: PostProjectsClassicCreateColumn) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/{}/columns", super::GITHUB_BASE_API_URL, project_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateColumn>(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() {
                304 => Err(ProjectsClassicCreateColumnError::Status304.into()),
                403 => Err(ProjectsClassicCreateColumnError::Status403(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicCreateColumnError::Status422(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicCreateColumnError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicCreateColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_column](https://docs.github.com/rest/projects-classic/columns#create-a-project-column)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_column(&self, project_id: i32, body: PostProjectsClassicCreateColumn) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/{}/columns", super::GITHUB_BASE_API_URL, project_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateColumn>(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() {
                304 => Err(ProjectsClassicCreateColumnError::Status304.into()),
                403 => Err(ProjectsClassicCreateColumnError::Status403(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicCreateColumnError::Status422(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicCreateColumnError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicCreateColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a user project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_authenticated_user](https://docs.github.com/rest/projects-classic/projects#create-a-user-project)
    ///
    /// ---
    pub async fn create_for_authenticated_user_async(&self, body: PostProjectsClassicCreateForAuthenticatedUser) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/user/projects", super::GITHUB_BASE_API_URL);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForAuthenticatedUser>(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() {
                304 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status304.into()),
                403 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status401(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicCreateForAuthenticatedUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a user project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_authenticated_user](https://docs.github.com/rest/projects-classic/projects#create-a-user-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_for_authenticated_user(&self, body: PostProjectsClassicCreateForAuthenticatedUser) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/user/projects", super::GITHUB_BASE_API_URL);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForAuthenticatedUser>(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() {
                304 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status304.into()),
                403 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status401(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicCreateForAuthenticatedUserError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicCreateForAuthenticatedUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create an organization project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_org](https://docs.github.com/rest/projects-classic/projects#create-an-organization-project)
    ///
    /// ---
    pub async fn create_for_org_async(&self, org: &str, body: PostProjectsClassicCreateForOrg) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/orgs/{}/projects", super::GITHUB_BASE_API_URL, org);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForOrg>(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() {
                401 => Err(ProjectsClassicCreateForOrgError::Status401(github_response.to_json_async().await?).into()),
                403 => Err(ProjectsClassicCreateForOrgError::Status403(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicCreateForOrgError::Status404(github_response.to_json_async().await?).into()),
                410 => Err(ProjectsClassicCreateForOrgError::Status410(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicCreateForOrgError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicCreateForOrgError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create an organization project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_org](https://docs.github.com/rest/projects-classic/projects#create-an-organization-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_for_org(&self, org: &str, body: PostProjectsClassicCreateForOrg) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/orgs/{}/projects", super::GITHUB_BASE_API_URL, org);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForOrg>(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() {
                401 => Err(ProjectsClassicCreateForOrgError::Status401(github_response.to_json()?).into()),
                403 => Err(ProjectsClassicCreateForOrgError::Status403(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicCreateForOrgError::Status404(github_response.to_json()?).into()),
                410 => Err(ProjectsClassicCreateForOrgError::Status410(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicCreateForOrgError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicCreateForOrgError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a repository project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_repo](https://docs.github.com/rest/projects-classic/projects#create-a-repository-project)
    ///
    /// ---
    pub async fn create_for_repo_async(&self, owner: &str, repo: &str, body: PostProjectsClassicCreateForRepo) -> Result<Project, AdapterError> {

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


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForRepo>(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() {
                401 => Err(ProjectsClassicCreateForRepoError::Status401(github_response.to_json_async().await?).into()),
                403 => Err(ProjectsClassicCreateForRepoError::Status403(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicCreateForRepoError::Status404(github_response.to_json_async().await?).into()),
                410 => Err(ProjectsClassicCreateForRepoError::Status410(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicCreateForRepoError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicCreateForRepoError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Create a repository project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for create_for_repo](https://docs.github.com/rest/projects-classic/projects#create-a-repository-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn create_for_repo(&self, owner: &str, repo: &str, body: PostProjectsClassicCreateForRepo) -> Result<Project, AdapterError> {

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


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicCreateForRepo>(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() {
                401 => Err(ProjectsClassicCreateForRepoError::Status401(github_response.to_json()?).into()),
                403 => Err(ProjectsClassicCreateForRepoError::Status403(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicCreateForRepoError::Status404(github_response.to_json()?).into()),
                410 => Err(ProjectsClassicCreateForRepoError::Status410(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicCreateForRepoError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicCreateForRepoError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete](https://docs.github.com/rest/projects-classic/projects#delete-a-project)
    ///
    /// ---
    pub async fn delete_async(&self, project_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        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() {
                304 => Err(ProjectsClassicDeleteError::Status304.into()),
                403 => Err(ProjectsClassicDeleteError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicDeleteError::Status401(github_response.to_json_async().await?).into()),
                410 => Err(ProjectsClassicDeleteError::Status410(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicDeleteError::Status404(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicDeleteError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete](https://docs.github.com/rest/projects-classic/projects#delete-a-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn delete(&self, project_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        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() {
                304 => Err(ProjectsClassicDeleteError::Status304.into()),
                403 => Err(ProjectsClassicDeleteError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicDeleteError::Status401(github_response.to_json()?).into()),
                410 => Err(ProjectsClassicDeleteError::Status410(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicDeleteError::Status404(github_response.to_json()?).into()),
                code => Err(ProjectsClassicDeleteError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete_card](https://docs.github.com/rest/projects-classic/cards#delete-a-project-card)
    ///
    /// ---
    pub async fn delete_card_async(&self, card_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        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() {
                304 => Err(ProjectsClassicDeleteCardError::Status304.into()),
                403 => Err(ProjectsClassicDeleteCardError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicDeleteCardError::Status401(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicDeleteCardError::Status404(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicDeleteCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete_card](https://docs.github.com/rest/projects-classic/cards#delete-a-project-card)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn delete_card(&self, card_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        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() {
                304 => Err(ProjectsClassicDeleteCardError::Status304.into()),
                403 => Err(ProjectsClassicDeleteCardError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicDeleteCardError::Status401(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicDeleteCardError::Status404(github_response.to_json()?).into()),
                code => Err(ProjectsClassicDeleteCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete_column](https://docs.github.com/rest/projects-classic/columns#delete-a-project-column)
    ///
    /// ---
    pub async fn delete_column_async(&self, column_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        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() {
                304 => Err(ProjectsClassicDeleteColumnError::Status304.into()),
                403 => Err(ProjectsClassicDeleteColumnError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicDeleteColumnError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicDeleteColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Delete a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for delete_column](https://docs.github.com/rest/projects-classic/columns#delete-a-project-column)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn delete_column(&self, column_id: i32) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        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() {
                304 => Err(ProjectsClassicDeleteColumnError::Status304.into()),
                403 => Err(ProjectsClassicDeleteColumnError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicDeleteColumnError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicDeleteColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get](https://docs.github.com/rest/projects-classic/projects#get-a-project)
    ///
    /// ---
    pub async fn get_async(&self, project_id: i32) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        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() {
                304 => Err(ProjectsClassicGetError::Status304.into()),
                403 => Err(ProjectsClassicGetError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicGetError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicGetError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get](https://docs.github.com/rest/projects-classic/projects#get-a-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get(&self, project_id: i32) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        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() {
                304 => Err(ProjectsClassicGetError::Status304.into()),
                403 => Err(ProjectsClassicGetError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicGetError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicGetError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_card](https://docs.github.com/rest/projects-classic/cards#get-a-project-card)
    ///
    /// ---
    pub async fn get_card_async(&self, card_id: i32) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        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() {
                304 => Err(ProjectsClassicGetCardError::Status304.into()),
                403 => Err(ProjectsClassicGetCardError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicGetCardError::Status401(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicGetCardError::Status404(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicGetCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_card](https://docs.github.com/rest/projects-classic/cards#get-a-project-card)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_card(&self, card_id: i32) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        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() {
                304 => Err(ProjectsClassicGetCardError::Status304.into()),
                403 => Err(ProjectsClassicGetCardError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicGetCardError::Status401(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicGetCardError::Status404(github_response.to_json()?).into()),
                code => Err(ProjectsClassicGetCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_column](https://docs.github.com/rest/projects-classic/columns#get-a-project-column)
    ///
    /// ---
    pub async fn get_column_async(&self, column_id: i32) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        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() {
                304 => Err(ProjectsClassicGetColumnError::Status304.into()),
                403 => Err(ProjectsClassicGetColumnError::Status403(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicGetColumnError::Status404(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicGetColumnError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicGetColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_column](https://docs.github.com/rest/projects-classic/columns#get-a-project-column)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_column(&self, column_id: i32) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        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() {
                304 => Err(ProjectsClassicGetColumnError::Status304.into()),
                403 => Err(ProjectsClassicGetColumnError::Status403(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicGetColumnError::Status404(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicGetColumnError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicGetColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get project permission for a user
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_permission_for_user](https://docs.github.com/rest/projects-classic/collaborators#get-project-permission-for-a-user)
    ///
    /// ---
    pub async fn get_permission_for_user_async(&self, project_id: i32, username: &str) -> Result<ProjectCollaboratorPermission, AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}/permission", super::GITHUB_BASE_API_URL, project_id, username);


        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(ProjectsClassicGetPermissionForUserError::Status404(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicGetPermissionForUserError::Status422(github_response.to_json_async().await?).into()),
                304 => Err(ProjectsClassicGetPermissionForUserError::Status304.into()),
                403 => Err(ProjectsClassicGetPermissionForUserError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicGetPermissionForUserError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicGetPermissionForUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Get project permission for a user
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for get_permission_for_user](https://docs.github.com/rest/projects-classic/collaborators#get-project-permission-for-a-user)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn get_permission_for_user(&self, project_id: i32, username: &str) -> Result<ProjectCollaboratorPermission, AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}/permission", super::GITHUB_BASE_API_URL, project_id, username);


        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(ProjectsClassicGetPermissionForUserError::Status404(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicGetPermissionForUserError::Status422(github_response.to_json()?).into()),
                304 => Err(ProjectsClassicGetPermissionForUserError::Status304.into()),
                403 => Err(ProjectsClassicGetPermissionForUserError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicGetPermissionForUserError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicGetPermissionForUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project cards
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_cards](https://docs.github.com/rest/projects-classic/cards#list-project-cards)
    ///
    /// ---
    pub async fn list_cards_async(&self, column_id: i32, query_params: Option<impl Into<ProjectsClassicListCardsParams<'api>>>) -> Result<Vec<ProjectCard>, AdapterError> {

        let mut request_uri = format!("{}/projects/columns/{}/cards", super::GITHUB_BASE_API_URL, column_id);

        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() {
                304 => Err(ProjectsClassicListCardsError::Status304.into()),
                403 => Err(ProjectsClassicListCardsError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicListCardsError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListCardsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project cards
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_cards](https://docs.github.com/rest/projects-classic/cards#list-project-cards)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_cards(&self, column_id: i32, query_params: Option<impl Into<ProjectsClassicListCardsParams<'api>>>) -> Result<Vec<ProjectCard>, AdapterError> {

        let mut request_uri = format!("{}/projects/columns/{}/cards", super::GITHUB_BASE_API_URL, column_id);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListCardsParams = 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() {
                304 => Err(ProjectsClassicListCardsError::Status304.into()),
                403 => Err(ProjectsClassicListCardsError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicListCardsError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListCardsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project collaborators
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_collaborators](https://docs.github.com/rest/projects-classic/collaborators#list-project-collaborators)
    ///
    /// ---
    pub async fn list_collaborators_async(&self, project_id: i32, query_params: Option<impl Into<ProjectsClassicListCollaboratorsParams<'api>>>) -> Result<Vec<SimpleUser>, AdapterError> {

        let mut request_uri = format!("{}/projects/{}/collaborators", super::GITHUB_BASE_API_URL, project_id);

        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() {
                404 => Err(ProjectsClassicListCollaboratorsError::Status404(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicListCollaboratorsError::Status422(github_response.to_json_async().await?).into()),
                304 => Err(ProjectsClassicListCollaboratorsError::Status304.into()),
                403 => Err(ProjectsClassicListCollaboratorsError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicListCollaboratorsError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListCollaboratorsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project collaborators
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_collaborators](https://docs.github.com/rest/projects-classic/collaborators#list-project-collaborators)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_collaborators(&self, project_id: i32, query_params: Option<impl Into<ProjectsClassicListCollaboratorsParams<'api>>>) -> Result<Vec<SimpleUser>, AdapterError> {

        let mut request_uri = format!("{}/projects/{}/collaborators", super::GITHUB_BASE_API_URL, project_id);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListCollaboratorsParams = 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() {
                404 => Err(ProjectsClassicListCollaboratorsError::Status404(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicListCollaboratorsError::Status422(github_response.to_json()?).into()),
                304 => Err(ProjectsClassicListCollaboratorsError::Status304.into()),
                403 => Err(ProjectsClassicListCollaboratorsError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicListCollaboratorsError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListCollaboratorsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project columns
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_columns](https://docs.github.com/rest/projects-classic/columns#list-project-columns)
    ///
    /// ---
    pub async fn list_columns_async(&self, project_id: i32, query_params: Option<impl Into<ProjectsClassicListColumnsParams>>) -> Result<Vec<ProjectColumn>, AdapterError> {

        let mut request_uri = format!("{}/projects/{}/columns", super::GITHUB_BASE_API_URL, project_id);

        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() {
                304 => Err(ProjectsClassicListColumnsError::Status304.into()),
                403 => Err(ProjectsClassicListColumnsError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicListColumnsError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListColumnsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List project columns
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_columns](https://docs.github.com/rest/projects-classic/columns#list-project-columns)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_columns(&self, project_id: i32, query_params: Option<impl Into<ProjectsClassicListColumnsParams>>) -> Result<Vec<ProjectColumn>, AdapterError> {

        let mut request_uri = format!("{}/projects/{}/columns", super::GITHUB_BASE_API_URL, project_id);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListColumnsParams = 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() {
                304 => Err(ProjectsClassicListColumnsError::Status304.into()),
                403 => Err(ProjectsClassicListColumnsError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicListColumnsError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListColumnsError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List organization projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_org](https://docs.github.com/rest/projects-classic/projects#list-organization-projects)
    ///
    /// ---
    pub async fn list_for_org_async(&self, org: &str, query_params: Option<impl Into<ProjectsClassicListForOrgParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

        let mut request_uri = format!("{}/orgs/{}/projects", super::GITHUB_BASE_API_URL, org);

        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(ProjectsClassicListForOrgError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListForOrgError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List organization projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_org](https://docs.github.com/rest/projects-classic/projects#list-organization-projects)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_for_org(&self, org: &str, query_params: Option<impl Into<ProjectsClassicListForOrgParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

        let mut request_uri = format!("{}/orgs/{}/projects", super::GITHUB_BASE_API_URL, org);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListForOrgParams = 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(ProjectsClassicListForOrgError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListForOrgError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List repository projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_repo](https://docs.github.com/rest/projects-classic/projects#list-repository-projects)
    ///
    /// ---
    pub async fn list_for_repo_async(&self, owner: &str, repo: &str, query_params: Option<impl Into<ProjectsClassicListForRepoParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

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

        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() {
                401 => Err(ProjectsClassicListForRepoError::Status401(github_response.to_json_async().await?).into()),
                403 => Err(ProjectsClassicListForRepoError::Status403(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicListForRepoError::Status404(github_response.to_json_async().await?).into()),
                410 => Err(ProjectsClassicListForRepoError::Status410(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicListForRepoError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListForRepoError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List repository projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_repo](https://docs.github.com/rest/projects-classic/projects#list-repository-projects)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_for_repo(&self, owner: &str, repo: &str, query_params: Option<impl Into<ProjectsClassicListForRepoParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

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

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListForRepoParams = 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() {
                401 => Err(ProjectsClassicListForRepoError::Status401(github_response.to_json()?).into()),
                403 => Err(ProjectsClassicListForRepoError::Status403(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicListForRepoError::Status404(github_response.to_json()?).into()),
                410 => Err(ProjectsClassicListForRepoError::Status410(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicListForRepoError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListForRepoError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List user projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_user](https://docs.github.com/rest/projects-classic/projects#list-user-projects)
    ///
    /// ---
    pub async fn list_for_user_async(&self, username: &str, query_params: Option<impl Into<ProjectsClassicListForUserParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

        let mut request_uri = format!("{}/users/{}/projects", super::GITHUB_BASE_API_URL, username);

        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(ProjectsClassicListForUserError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicListForUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # List user projects
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for list_for_user](https://docs.github.com/rest/projects-classic/projects#list-user-projects)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn list_for_user(&self, username: &str, query_params: Option<impl Into<ProjectsClassicListForUserParams<'api>>>) -> Result<Vec<Project>, AdapterError> {

        let mut request_uri = format!("{}/users/{}/projects", super::GITHUB_BASE_API_URL, username);

        if let Some(params) = query_params {
            request_uri.push_str("?");
            let qp: ProjectsClassicListForUserParams = 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(ProjectsClassicListForUserError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicListForUserError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Move a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for move_card](https://docs.github.com/rest/projects-classic/cards#move-a-project-card)
    ///
    /// ---
    pub async fn move_card_async(&self, card_id: i32, body: PostProjectsClassicMoveCard) -> Result<HashMap<String, Value>, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}/moves", super::GITHUB_BASE_API_URL, card_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicMoveCard>(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() {
                304 => Err(ProjectsClassicMoveCardError::Status304.into()),
                403 => Err(ProjectsClassicMoveCardError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicMoveCardError::Status401(github_response.to_json_async().await?).into()),
                503 => Err(ProjectsClassicMoveCardError::Status503(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicMoveCardError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicMoveCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Move a project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for move_card](https://docs.github.com/rest/projects-classic/cards#move-a-project-card)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn move_card(&self, card_id: i32, body: PostProjectsClassicMoveCard) -> Result<HashMap<String, Value>, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}/moves", super::GITHUB_BASE_API_URL, card_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicMoveCard>(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() {
                304 => Err(ProjectsClassicMoveCardError::Status304.into()),
                403 => Err(ProjectsClassicMoveCardError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicMoveCardError::Status401(github_response.to_json()?).into()),
                503 => Err(ProjectsClassicMoveCardError::Status503(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicMoveCardError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicMoveCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Move a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for move_column](https://docs.github.com/rest/projects-classic/columns#move-a-project-column)
    ///
    /// ---
    pub async fn move_column_async(&self, column_id: i32, body: PostProjectsClassicMoveColumn) -> Result<HashMap<String, Value>, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}/moves", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicMoveColumn>(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() {
                304 => Err(ProjectsClassicMoveColumnError::Status304.into()),
                403 => Err(ProjectsClassicMoveColumnError::Status403(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicMoveColumnError::Status422(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicMoveColumnError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicMoveColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Move a project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for move_column](https://docs.github.com/rest/projects-classic/columns#move-a-project-column)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn move_column(&self, column_id: i32, body: PostProjectsClassicMoveColumn) -> Result<HashMap<String, Value>, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}/moves", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PostProjectsClassicMoveColumn>(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() {
                304 => Err(ProjectsClassicMoveColumnError::Status304.into()),
                403 => Err(ProjectsClassicMoveColumnError::Status403(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicMoveColumnError::Status422(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicMoveColumnError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicMoveColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Remove user as a collaborator
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for remove_collaborator](https://docs.github.com/rest/projects-classic/collaborators#remove-user-as-a-collaborator)
    ///
    /// ---
    pub async fn remove_collaborator_async(&self, project_id: i32, username: &str) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}", super::GITHUB_BASE_API_URL, project_id, username);


        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() {
                304 => Err(ProjectsClassicRemoveCollaboratorError::Status304.into()),
                404 => Err(ProjectsClassicRemoveCollaboratorError::Status404(github_response.to_json_async().await?).into()),
                403 => Err(ProjectsClassicRemoveCollaboratorError::Status403(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicRemoveCollaboratorError::Status422(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicRemoveCollaboratorError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicRemoveCollaboratorError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Remove user as a collaborator
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for remove_collaborator](https://docs.github.com/rest/projects-classic/collaborators#remove-user-as-a-collaborator)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn remove_collaborator(&self, project_id: i32, username: &str) -> Result<(), AdapterError> {

        let request_uri = format!("{}/projects/{}/collaborators/{}", super::GITHUB_BASE_API_URL, project_id, username);


        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() {
                304 => Err(ProjectsClassicRemoveCollaboratorError::Status304.into()),
                404 => Err(ProjectsClassicRemoveCollaboratorError::Status404(github_response.to_json()?).into()),
                403 => Err(ProjectsClassicRemoveCollaboratorError::Status403(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicRemoveCollaboratorError::Status422(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicRemoveCollaboratorError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicRemoveCollaboratorError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update](https://docs.github.com/rest/projects-classic/projects#update-a-project)
    ///
    /// ---
    pub async fn update_async(&self, project_id: i32, body: PatchProjectsClassicUpdate) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdate>(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() {
                404 => Err(ProjectsClassicUpdateError::Status404.into()),
                304 => Err(ProjectsClassicUpdateError::Status304.into()),
                403 => Err(ProjectsClassicUpdateError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicUpdateError::Status401(github_response.to_json_async().await?).into()),
                410 => Err(ProjectsClassicUpdateError::Status410(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicUpdateError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicUpdateError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update a project
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update](https://docs.github.com/rest/projects-classic/projects#update-a-project)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn update(&self, project_id: i32, body: PatchProjectsClassicUpdate) -> Result<Project, AdapterError> {

        let request_uri = format!("{}/projects/{}", super::GITHUB_BASE_API_URL, project_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdate>(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() {
                404 => Err(ProjectsClassicUpdateError::Status404.into()),
                304 => Err(ProjectsClassicUpdateError::Status304.into()),
                403 => Err(ProjectsClassicUpdateError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicUpdateError::Status401(github_response.to_json()?).into()),
                410 => Err(ProjectsClassicUpdateError::Status410(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicUpdateError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicUpdateError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update an existing project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update_card](https://docs.github.com/rest/projects-classic/cards#update-an-existing-project-card)
    ///
    /// ---
    pub async fn update_card_async(&self, card_id: i32, body: PatchProjectsClassicUpdateCard) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdateCard>(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() {
                304 => Err(ProjectsClassicUpdateCardError::Status304.into()),
                403 => Err(ProjectsClassicUpdateCardError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicUpdateCardError::Status401(github_response.to_json_async().await?).into()),
                404 => Err(ProjectsClassicUpdateCardError::Status404(github_response.to_json_async().await?).into()),
                422 => Err(ProjectsClassicUpdateCardError::Status422(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicUpdateCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update an existing project card
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update_card](https://docs.github.com/rest/projects-classic/cards#update-an-existing-project-card)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn update_card(&self, card_id: i32, body: PatchProjectsClassicUpdateCard) -> Result<ProjectCard, AdapterError> {

        let request_uri = format!("{}/projects/columns/cards/{}", super::GITHUB_BASE_API_URL, card_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdateCard>(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() {
                304 => Err(ProjectsClassicUpdateCardError::Status304.into()),
                403 => Err(ProjectsClassicUpdateCardError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicUpdateCardError::Status401(github_response.to_json()?).into()),
                404 => Err(ProjectsClassicUpdateCardError::Status404(github_response.to_json()?).into()),
                422 => Err(ProjectsClassicUpdateCardError::Status422(github_response.to_json()?).into()),
                code => Err(ProjectsClassicUpdateCardError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update an existing project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update_column](https://docs.github.com/rest/projects-classic/columns#update-an-existing-project-column)
    ///
    /// ---
    pub async fn update_column_async(&self, column_id: i32, body: PatchProjectsClassicUpdateColumn) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdateColumn>(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() {
                304 => Err(ProjectsClassicUpdateColumnError::Status304.into()),
                403 => Err(ProjectsClassicUpdateColumnError::Status403(github_response.to_json_async().await?).into()),
                401 => Err(ProjectsClassicUpdateColumnError::Status401(github_response.to_json_async().await?).into()),
                code => Err(ProjectsClassicUpdateColumnError::Generic { code }.into()),
            }
        }
    }

    /// ---
    ///
    /// # Update an existing project column
    ///
    /// > [!WARNING]
    /// > **Closing down notice:** Projects (classic) is being deprecated in favor of the new Projects experience.
    /// > See the [changelog](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) for more information.
    ///
    /// [GitHub API docs for update_column](https://docs.github.com/rest/projects-classic/columns#update-an-existing-project-column)
    ///
    /// ---
    #[cfg(not(target_arch = "wasm32"))]
    pub fn update_column(&self, column_id: i32, body: PatchProjectsClassicUpdateColumn) -> Result<ProjectColumn, AdapterError> {

        let request_uri = format!("{}/projects/columns/{}", super::GITHUB_BASE_API_URL, column_id);


        let req = GitHubRequest {
            uri: request_uri,
            body: Some(C::from_json::<PatchProjectsClassicUpdateColumn>(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() {
                304 => Err(ProjectsClassicUpdateColumnError::Status304.into()),
                403 => Err(ProjectsClassicUpdateColumnError::Status403(github_response.to_json()?).into()),
                401 => Err(ProjectsClassicUpdateColumnError::Status401(github_response.to_json()?).into()),
                code => Err(ProjectsClassicUpdateColumnError::Generic { code }.into()),
            }
        }
    }

}