gitbundle_sdk/apis/

repository_api.rs

/*
 * GitBundle API
 *
 * GitBundle API documentation.
 *
 * The version of the OpenAPI document: 3.0.0
 *
 * Generated by: https://openapi-generator.tech
 */

use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};

use super::{configuration, ContentType, Error};
use crate::{apis::ResponseContent, models};

/// struct for typed errors of method [`commit_files`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CommitFilesError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`commits_calculate_divergence`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CommitsCalculateDivergenceError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_branch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteBranchError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_release`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteReleaseError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_repository_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteRepositoryRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_repository_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteRepositoryVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_tag`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteTagError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`general_update`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GeneralUpdateError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_archive`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetArchiveError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_blame`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetBlameError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_branch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetBranchError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_branches`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetBranchesError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_codeowners_validate`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCodeownersValidateError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_commit`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommitError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_commit_diff`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommitDiffError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_commit_file_content`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommitFileContentError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_commits`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommitsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_content`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetContentError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_contributors`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetContributorsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_diff_stats`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDiffStatsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_diffs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDiffsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_forks`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetForksError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_general`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetGeneralError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_has_starred`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetHasStarredError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_import_progress`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetImportProgressError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_paths`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetPathsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_raw`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRawError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_release`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReleaseError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_releases`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReleasesError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repo`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepoError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_reseted_runner_register_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryResetedRunnerRegisterTokenError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_runner_register_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryRunnerRegisterTokenError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_runners`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryRunnersError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_service_accounts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryServiceAccountsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_stats`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryStatsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_repository_variables`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRepositoryVariablesError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_security`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSecurityError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_stars`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetStarsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_tags`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTagsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_repo`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchRepoError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_repository_runner`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchRepositoryRunnerError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_repository_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchRepositoryVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_security`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchSecurityError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_stars`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchStarsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_branch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostBranchError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_default_branch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostDefaultBranchError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_diffs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostDiffsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_merge_check`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostMergeCheckError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_path_details`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostPathDetailsError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_release`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostReleaseError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_repo`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRepoError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_repository_import`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRepositoryImportError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_repository_move`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRepositoryMoveError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_repository_purge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRepositoryPurgeError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_repository_variable`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostRepositoryVariableError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_tag`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostTagError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`rename_branch`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RenameBranchError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status422(models::RuleCheckOutput),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`repo_restore`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RepoRestoreError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`soft_repository_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SoftRepositoryDeleteError {
    Status400(models::JsonErrorResponseNull),
    Status401(models::JsonErrorResponseNull),
    Status403(models::JsonErrorResponseNull),
    Status404(models::JsonErrorResponseNull),
    Status409(models::JsonErrorResponseNull),
    Status429(models::JsonErrorResponseNull),
    Status500(models::JsonErrorResponseNull),
    UnknownValue(serde_json::Value),
}

pub async fn commit_files(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    commit_files_input: models::CommitFilesInput,
) -> Result<models::CommitFilesOutput, Error<CommitFilesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_commit_files_input = commit_files_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_commit_files_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommitFilesOutput`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CommitFilesOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CommitFilesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn commits_calculate_divergence(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_commit_divergences_input: models::RepoCommitDivergencesInput,
) -> Result<Vec<models::CommitDivergence>, Error<CommitsCalculateDivergenceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_commit_divergences_input = repo_commit_divergences_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits/calculate-divergence",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_commit_divergences_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::CommitDivergence&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::CommitDivergence&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CommitsCalculateDivergenceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_branch(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    branch_name: &str,
    bypass_rules: Option<bool>,
) -> Result<(), Error<DeleteBranchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_branch_name = branch_name;
    let p_query_bypass_rules = bypass_rules;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/branches/{branch_name}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        branch_name = crate::apis::urlencode(p_path_branch_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_bypass_rules {
        req_builder = req_builder.query(&[("bypass_rules", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteBranchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_release(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    tag_ref: &str,
    bypass_rules: Option<bool>,
) -> Result<(), Error<DeleteReleaseError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_tag_ref = tag_ref;
    let p_query_bypass_rules = bypass_rules;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/releases/{tag_ref}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        tag_ref = crate::apis::urlencode(p_path_tag_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_bypass_rules {
        req_builder = req_builder.query(&[("bypass_rules", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteReleaseError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_repository_runner(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    runner_uuid: &str,
) -> Result<(), Error<DeleteRepositoryRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_runner_uuid = runner_uuid;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRepositoryRunnerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_repository_variable(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    variable_identifier: &str,
) -> Result<(), Error<DeleteRepositoryVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_variable_identifier = variable_identifier;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRepositoryVariableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn delete_tag(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    tag_name: &str,
    bypass_rules: Option<bool>,
) -> Result<(), Error<DeleteTagError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_tag_name = tag_name;
    let p_query_bypass_rules = bypass_rules;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/tags/{tag_name}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        tag_name = crate::apis::urlencode(p_path_tag_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_bypass_rules {
        req_builder = req_builder.query(&[("bypass_rules", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteTagError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn general_update(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    general_settings: models::GeneralSettings,
) -> Result<models::GeneralSettings, Error<GeneralUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_general_settings = general_settings;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/settings/general",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_general_settings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GeneralSettings`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GeneralSettings`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GeneralUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_archive(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    archive_ref: &str,
    prefix: Option<&str>,
    attributes: Option<models::ArchiveAttribute>,
    paths: Option<Vec<String>>,
    timestamp: Option<i64>,
    compression: Option<i32>,
) -> Result<Vec<i32>, Error<GetArchiveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_archive_ref = archive_ref;
    let p_query_prefix = prefix;
    let p_query_attributes = attributes;
    let p_query_paths = paths;
    let p_query_timestamp = timestamp;
    let p_query_compression = compression;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/archive/{archive_ref}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        archive_ref = crate::apis::urlencode(p_path_archive_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_prefix {
        req_builder = req_builder.query(&[("prefix", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_attributes {
        req_builder = req_builder.query(&[("attributes", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_paths {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .iter()
                    .map(|p| ("paths".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "paths",
                &param_value
                    .iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_timestamp {
        req_builder = req_builder.query(&[("timestamp", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_compression {
        req_builder = req_builder.query(&[("compression", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;i32&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;i32&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetArchiveError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_blame(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
    git_ref: Option<&str>,
    line_from: Option<i64>,
    line_to: Option<i64>,
) -> Result<Vec<models::BlamePart>, Error<GetBlameError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;
    let p_query_git_ref = git_ref;
    let p_query_line_from = line_from;
    let p_query_line_to = line_to;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/blame/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_line_from {
        req_builder = req_builder.query(&[("line_from", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_line_to {
        req_builder = req_builder.query(&[("line_to", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::BlamePart&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::BlamePart&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetBlameError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_branch(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    branch_name: &str,
) -> Result<models::CommitBranch, Error<GetBranchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_branch_name = branch_name;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/branches/{branch_name}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        branch_name = crate::apis::urlencode(p_path_branch_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommitBranch`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CommitBranch`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetBranchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_branches(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    include_commit: Option<bool>,
) -> Result<Vec<models::CommitBranch>, Error<GetBranchesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_include_commit = include_commit;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/branches",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_commit {
        req_builder = req_builder.query(&[("include_commit", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::CommitBranch&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::CommitBranch&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetBranchesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_codeowners_validate(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    git_ref: Option<&str>,
) -> Result<models::CodeOwnersValidation, Error<GetCodeownersValidateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_git_ref = git_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/codeowners/validate",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CodeOwnersValidation`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CodeOwnersValidation`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCodeownersValidateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_commit(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    commit_sha: &str,
) -> Result<models::Commit, Error<GetCommitError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_commit_sha = commit_sha;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits/{commit_sha}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        commit_sha = crate::apis::urlencode(p_path_commit_sha)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Commit`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Commit`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommitError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_commit_diff(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    commit_sha: &str,
) -> Result<String, Error<GetCommitDiffError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_commit_sha = commit_sha;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits/{commit_sha}/diff",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        commit_sha = crate::apis::urlencode(p_path_commit_sha)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommitDiffError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_commit_file_content(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    commit_sha: &str,
    file_path: &str,
    hunk_header: &str,
    expand_up: bool,
    size: Option<i32>,
) -> Result<models::DiffFileContent, Error<GetCommitFileContentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_commit_sha = commit_sha;
    let p_query_file_path = file_path;
    let p_query_hunk_header = hunk_header;
    let p_query_expand_up = expand_up;
    let p_query_size = size;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits/{commit_sha}/content",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        commit_sha = crate::apis::urlencode(p_path_commit_sha)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("file_path", &p_query_file_path.to_string())]);
    req_builder = req_builder.query(&[("hunk_header", &p_query_hunk_header.to_string())]);
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("expand_up", &p_query_expand_up.to_string())]);
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DiffFileContent`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DiffFileContent`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommitFileContentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_commits(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    git_ref: Option<&str>,
    page: Option<i64>,
    size: Option<i64>,
    after: Option<&str>,
    path: Option<&str>,
    since: Option<i64>,
    until: Option<i64>,
    author: Option<&str>,
    include_stats: Option<bool>,
) -> Result<Vec<models::CommitWithPathRenameDetails>, Error<GetCommitsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_git_ref = git_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_after = after;
    let p_query_path = path;
    let p_query_since = since;
    let p_query_until = until;
    let p_query_author = author;
    let p_query_include_stats = include_stats;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/commits",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_path {
        req_builder = req_builder.query(&[("path", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_since {
        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_until {
        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_author {
        req_builder = req_builder.query(&[("author", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_stats {
        req_builder = req_builder.query(&[("include_stats", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::CommitWithPathRenameDetails&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::CommitWithPathRenameDetails&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommitsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_content(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
    git_ref: Option<&str>,
    include_commit: Option<bool>,
) -> Result<models::RepoContentOutput, Error<GetContentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;
    let p_query_git_ref = git_ref;
    let p_query_include_commit = include_commit;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/content/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_commit {
        req_builder = req_builder.query(&[("include_commit", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepoContentOutput`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepoContentOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetContentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_contributors(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    git_ref: Option<&str>,
    since: Option<i64>,
    until: Option<i64>,
) -> Result<Vec<models::Contributor>, Error<GetContributorsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_git_ref = git_ref;
    let p_query_since = since;
    let p_query_until = until;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/contributors",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_since {
        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_until {
        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Contributor&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Contributor&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetContributorsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_diff_stats(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
) -> Result<models::DiffStats, Error<GetDiffStatsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/diff-stats/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DiffStats`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DiffStats`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetDiffStatsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_diffs(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
) -> Result<String, Error<GetDiffsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/diff/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetDiffsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_forks(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::RepoSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::RepositoryModel>, Error<GetForksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/forks",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepositoryModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepositoryModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetForksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_general(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::GeneralSettings, Error<GetGeneralError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/settings/general",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GeneralSettings`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GeneralSettings`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetGeneralError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_has_starred(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::RepositoryStarModel, Error<GetHasStarredError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/stars/has_starred",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryStarModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryStarModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetHasStarredError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_import_progress(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::JobProgress, Error<GetImportProgressError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/import-progress",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::JobProgress`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::JobProgress`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetImportProgressError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_paths(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    git_ref: Option<&str>,
    include_directories: Option<bool>,
) -> Result<models::RepoPathsOutput, Error<GetPathsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_git_ref = git_ref;
    let p_query_include_directories = include_directories;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/paths",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_directories {
        req_builder = req_builder.query(&[("include_directories", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepoPathsOutput`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepoPathsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetPathsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_raw(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
    git_ref: Option<&str>,
) -> Result<Vec<i32>, Error<GetRawError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;
    let p_query_git_ref = git_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/raw/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;i32&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;i32&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRawError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_release(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    tag_ref: &str,
) -> Result<models::ReleaseCreator, Error<GetReleaseError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_tag_ref = tag_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/releases/{tag_ref}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        tag_ref = crate::apis::urlencode(p_path_tag_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ReleaseCreator`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ReleaseCreator`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetReleaseError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_releases(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::ReleaseSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::ReleaseCreator>, Error<GetReleasesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/releases",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ReleaseCreator&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ReleaseCreator&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetReleasesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repo(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::RepoParent, Error<GetRepoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepoParent`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepoParent`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_reseted_runner_register_token(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::RegisterTokenModel, Error<GetRepositoryResetedRunnerRegisterTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners/register_token/reseted",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RegisterTokenModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RegisterTokenModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryResetedRunnerRegisterTokenError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_runner(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    runner_uuid: &str,
) -> Result<models::RunnerModel, Error<GetRepositoryRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_runner_uuid = runner_uuid;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunnerModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunnerModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryRunnerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_runner_register_token(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::RegisterTokenModel, Error<GetRepositoryRunnerRegisterTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners/register_token",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RegisterTokenModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RegisterTokenModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryRunnerRegisterTokenError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_runners(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
) -> Result<Vec<models::RunnerCreator>, Error<GetRepositoryRunnersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RunnerCreator&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RunnerCreator&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryRunnersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_service_accounts(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<Vec<models::UserModel>, Error<GetRepositoryServiceAccountsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/service-accounts",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryServiceAccountsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_stats(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::RepoStatsOutput, Error<GetRepositoryStatsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/stats",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepoStatsOutput`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepoStatsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryStatsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_variable(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    variable_identifier: &str,
) -> Result<models::VariableModel, Error<GetRepositoryVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_variable_identifier = variable_identifier;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VariableModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VariableModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryVariableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_repository_variables(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    types: Option<Vec<models::VariableType>>,
    sort: Option<models::VariableSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::VariableGroup>, Error<GetRepositoryVariablesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_types = types;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/variables",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_types {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .iter()
                    .map(|p| ("types".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "types",
                &param_value
                    .iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::VariableGroup&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::VariableGroup&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRepositoryVariablesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_security(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<models::SecuritySettings, Error<GetSecurityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/settings/security",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SecuritySettings`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SecuritySettings`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSecurityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_stars(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    sort: Option<models::UserSort>,
    order: Option<models::OrderOption>,
) -> Result<Vec<models::UserModel>, Error<GetStarsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_sort = sort;
    let p_query_order = order;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/stars",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetStarsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_tags(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    page: Option<i64>,
    size: Option<i64>,
    query: Option<&str>,
    include_commit: Option<bool>,
) -> Result<Vec<models::CommitTag>, Error<GetTagsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_page = page;
    let p_query_size = size;
    let p_query_query = query;
    let p_query_include_commit = include_commit;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/tags",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_commit {
        req_builder = req_builder.query(&[("include_commit", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::CommitTag&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::CommitTag&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetTagsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_repo(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_update_input: models::RepoUpdateInput,
) -> Result<models::RepositoryModel, Error<PatchRepoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_update_input = repo_update_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_update_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchRepoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_repository_runner(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    runner_uuid: &str,
    runner_patch_input: models::RunnerPatchInput,
) -> Result<models::RunnerModel, Error<PatchRepositoryRunnerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_runner_uuid = runner_uuid;
    let p_body_runner_patch_input = runner_patch_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/runners/{runner_uuid}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        runner_uuid = crate::apis::urlencode(p_path_runner_uuid)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_runner_patch_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunnerModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunnerModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchRepositoryRunnerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_repository_variable(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    variable_identifier: &str,
    variable_patch_input: models::VariablePatchInput,
) -> Result<models::VariableModel, Error<PatchRepositoryVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_variable_identifier = variable_identifier;
    let p_body_variable_patch_input = variable_patch_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/variables/{variable_identifier}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        variable_identifier = crate::apis::urlencode(p_path_variable_identifier)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_variable_patch_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VariableModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VariableModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchRepositoryVariableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_security(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    security_settings: models::SecuritySettings,
) -> Result<models::SecuritySettings, Error<PatchSecurityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_security_settings = security_settings;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/settings/security",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_security_settings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SecuritySettings`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SecuritySettings`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchSecurityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn patch_stars(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_stars_input: models::RepoStarsInput,
) -> Result<models::RepositoryModel, Error<PatchStarsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_stars_input = repo_stars_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/stars",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_stars_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchStarsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_branch(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    branch_create_input: models::BranchCreateInput,
) -> Result<models::CommitBranch, Error<PostBranchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_branch_create_input = branch_create_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/branches",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_branch_create_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommitBranch`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CommitBranch`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostBranchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_default_branch(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_update_default_branch_input: models::RepoUpdateDefaultBranchInput,
) -> Result<models::RepositoryModel, Error<PostDefaultBranchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_update_default_branch_input = repo_update_default_branch_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/default-branch",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_update_default_branch_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostDefaultBranchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_diffs(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
    path2: &str,
    commit_diff_file: Vec<models::CommitDiffFile>,
) -> Result<Vec<i32>, Error<PostDiffsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_query_path = path;
    let p_path_path = path2;
    let p_body_commit_diff_file = commit_diff_file;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/diff/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("path", &p_query_path.to_string())]);
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_commit_diff_file);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;i32&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;i32&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostDiffsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_merge_check(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    path: &str,
    repo_merge_check_input: models::RepoMergeCheckInput,
) -> Result<models::RepoMergeCheckOutput, Error<PostMergeCheckError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_path_path = path;
    let p_body_repo_merge_check_input = repo_merge_check_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/merge-check/{path}",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref),
        path = crate::apis::urlencode(p_path_path)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_merge_check_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepoMergeCheckOutput`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepoMergeCheckOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostMergeCheckError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_path_details(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    request_body: Vec<String>,
    git_ref: Option<&str>,
) -> Result<Vec<models::PathDetails>, Error<PostPathDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_request_body = request_body;
    let p_query_git_ref = git_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/path-details",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_git_ref {
        req_builder = req_builder.query(&[("git_ref", &param_value.to_string())]);
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_request_body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::PathDetails&gt;`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::PathDetails&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostPathDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_release(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    release_create_input: models::ReleaseCreateInput,
) -> Result<models::ReleaseModel, Error<PostReleaseError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_release_create_input = release_create_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/releases",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_release_create_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ReleaseModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ReleaseModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostReleaseError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_repo(
    configuration: &configuration::Configuration,
    repo_create_input: models::RepoCreateInput,
) -> Result<models::RepositoryModel, Error<PostRepoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_repo_create_input = repo_create_input;

    let uri_str = format!("{}/repos", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_create_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostRepoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_repository_import(
    configuration: &configuration::Configuration,
    repo_import_input: models::RepoImportInput,
) -> Result<models::RepositoryModel, Error<PostRepositoryImportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_repo_import_input = repo_import_input;

    let uri_str = format!("{}/repos/import", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_import_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostRepositoryImportError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_repository_move(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_move_input: models::RepoMoveInput,
) -> Result<models::RepositoryModel, Error<PostRepositoryMoveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_move_input = repo_move_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/move",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_move_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostRepositoryMoveError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_repository_purge(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<(), Error<PostRepositoryPurgeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/purge",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<PostRepositoryPurgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_repository_variable(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    variable_create_input: models::VariableCreateInput,
) -> Result<models::VariableModel, Error<PostRepositoryVariableError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_variable_create_input = variable_create_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/variables",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_variable_create_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VariableModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VariableModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostRepositoryVariableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn post_tag(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    tag_create_input: models::TagCreateInput,
) -> Result<models::CommitTag, Error<PostTagError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_tag_create_input = tag_create_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/tags",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_tag_create_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommitTag`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CommitTag`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PostTagError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn rename_branch(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    branch_rename_input: models::BranchRenameInput,
) -> Result<models::CommitBranch, Error<RenameBranchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_branch_rename_input = branch_rename_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/branches",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_branch_rename_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommitBranch`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CommitBranch`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RenameBranchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn repo_restore(
    configuration: &configuration::Configuration,
    repo_ref: &str,
    repo_restore_input: models::RepoRestoreInput,
) -> Result<models::RepositoryModel, Error<RepoRestoreError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;
    let p_body_repo_restore_input = repo_restore_input;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+/restore",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_repo_restore_input);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RepositoryModel`"))),
            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RepositoryModel`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RepoRestoreError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn soft_repository_delete(
    configuration: &configuration::Configuration,
    repo_ref: &str,
) -> Result<(), Error<SoftRepositoryDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_repo_ref = repo_ref;

    let uri_str = format!(
        "{}/repos/{repo_ref}/+",
        configuration.base_path,
        repo_ref = crate::apis::urlencode(p_path_repo_ref)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.query(&[("access_token", value)]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<SoftRepositoryDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}