From 81b17abc8aa286e7cc94b08079832916b5e89d10 Mon Sep 17 00:00:00 2001 From: Cyborus Date: Thu, 18 Jan 2024 13:44:07 -0500 Subject: [PATCH] replace with generated api --- src/admin.rs | 502 -- src/generated.rs | 12253 ++++++++++++++++++++++++++++++++++++++++++ src/issue.rs | 347 -- src/lib.rs | 220 +- src/misc.rs | 162 - src/notification.rs | 273 - src/organization.rs | 30 - src/package.rs | 174 - src/repository.rs | 743 --- src/user.rs | 59 - 10 files changed, 12272 insertions(+), 2491 deletions(-) delete mode 100644 src/admin.rs create mode 100644 src/generated.rs delete mode 100644 src/issue.rs delete mode 100644 src/misc.rs delete mode 100644 src/notification.rs delete mode 100644 src/organization.rs delete mode 100644 src/package.rs delete mode 100644 src/repository.rs delete mode 100644 src/user.rs diff --git a/src/admin.rs b/src/admin.rs deleted file mode 100644 index 560d6c6..0000000 --- a/src/admin.rs +++ /dev/null @@ -1,502 +0,0 @@ -use super::*; - -use std::collections::BTreeMap; -use std::fmt::Write; - -impl Forgejo { - pub async fn admin_get_crons(&self, query: CronQuery) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_run_cron(&self, name: &str) -> Result<(), ForgejoError> { - self.post_unit(&format!("admin/cron/{name}"), &()).await - } - - pub async fn admin_get_emails( - &self, - query: EmailListQuery, - ) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_search_emails( - &self, - query: EmailSearchQuery, - ) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_get_hooks(&self, query: HookQuery) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_create_hook(&self, opt: CreateHookOption) -> Result { - self.post("admin/hooks", &opt).await - } - - pub async fn admin_get_hook(&self, id: u64) -> Result, ForgejoError> { - self.get_opt(&format!("admin/hooks/{id}")).await - } - - pub async fn admin_delete_hook(&self, id: u64) -> Result<(), ForgejoError> { - self.delete(&format!("admin/hooks/{id}")).await - } - - pub async fn admin_edit_hook( - &self, - id: u64, - opt: EditHookOption, - ) -> Result { - self.patch(&format!("admin/hooks/{id}"), &opt).await - } - - pub async fn admin_get_orgs( - &self, - query: AdminOrganizationQuery, - ) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_unadopted_repos( - &self, - query: UnadoptedRepoQuery, - ) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_adopt(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { - self.post(&format!("admin/unadopted/{owner}/{repo}"), &()) - .await - } - - pub async fn admin_delete_unadopted( - &self, - owner: &str, - repo: &str, - ) -> Result<(), ForgejoError> { - self.delete(&format!("admin/unadopted/{owner}/{repo}")) - .await - } - - pub async fn admin_users(&self, query: AdminUserQuery) -> Result, ForgejoError> { - self.get(&query.path()).await - } - - pub async fn admin_create_user(&self, opt: CreateUserOption) -> Result { - self.post("admin/users", &opt).await - } - - pub async fn admin_delete_user(&self, user: &str, purge: bool) -> Result<(), ForgejoError> { - self.delete(&format!("admin/users/{user}?purge={purge}")) - .await - } - - pub async fn admin_edit_user( - &self, - user: &str, - opt: CreateUserOption, - ) -> Result { - self.patch(&format!("admin/users/{user}"), &opt).await - } - - pub async fn admin_add_key( - &self, - user: &str, - opt: CreateKeyOption, - ) -> Result { - self.post(&format!("admin/users/{user}/keys"), &opt).await - } - - pub async fn admin_delete_key(&self, user: &str, id: u64) -> Result<(), ForgejoError> { - self.delete(&format!("admin/users/{user}/keys/{id}")).await - } - - pub async fn admin_create_org( - &self, - owner: &str, - opt: CreateOrgOption, - ) -> Result { - self.post(&format!("admin/users/{owner}/orgs"), &opt).await - } - - pub async fn admin_rename_user( - &self, - user: &str, - opt: RenameUserOption, - ) -> Result<(), ForgejoError> { - self.post_unit(&format!("admin/users/{user}/rename"), &opt) - .await - } - - pub async fn admin_create_repo( - &self, - owner: &str, - opt: CreateRepoOption, - ) -> Result { - self.post(&format!("admin/users/{owner}/repos"), &opt).await - } -} - -#[derive(serde::Deserialize, Debug, PartialEq)] -pub struct Cron { - pub exec_times: u64, - pub name: String, - #[serde(with = "time::serde::rfc3339")] - pub next: time::OffsetDateTime, - #[serde(with = "time::serde::rfc3339")] - pub prev: time::OffsetDateTime, - pub schedule: String, -} - -#[derive(Default, Debug)] -pub struct CronQuery { - pub page: Option, - pub limit: Option, -} - -impl CronQuery { - fn path(&self) -> String { - let mut s = String::from("admin/cron?"); - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(serde::Deserialize, Debug, PartialEq)] -pub struct Email { - pub email: String, - pub primary: bool, - pub user_id: u64, - pub username: String, - pub verified: bool, -} - -#[derive(Default, Debug)] -pub struct EmailListQuery { - pub page: Option, - pub limit: Option, -} - -impl EmailListQuery { - fn path(&self) -> String { - let mut s = String::from("admin/emails?"); - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(Default, Debug)] -pub struct EmailSearchQuery { - pub query: String, - pub page: Option, - pub limit: Option, -} - -impl EmailSearchQuery { - fn path(&self) -> String { - let mut s = String::from("admin/emails/search?"); - if !self.query.is_empty() { - s.push_str("q="); - s.push_str(&self.query); - s.push('&'); - } - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(serde::Deserialize, Debug, PartialEq)] -pub struct Hook { - pub active: bool, - pub authorization_header: String, - pub branch_filter: String, - pub config: std::collections::BTreeMap, - #[serde(with = "time::serde::rfc3339")] - pub created_at: time::OffsetDateTime, - pub events: Vec, - pub id: u64, - #[serde(rename = "type")] - pub _type: HookType, - #[serde(with = "time::serde::rfc3339")] - pub updated_at: time::OffsetDateTime, -} - -#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)] -#[non_exhaustive] -#[serde(rename_all = "lowercase")] -pub enum HookType { - Forgejo, - Dingtalk, - Discord, - Gitea, - Gogs, - Msteams, - Slack, - Telegram, - Feishu, - Wechatwork, - Packagist, -} - -#[derive(Default, Debug)] -pub struct HookQuery { - pub page: Option, - pub limit: Option, -} - -impl HookQuery { - fn path(&self) -> String { - let mut s = String::from("admin/hooks?"); - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct CreateHookOption { - pub active: Option, - pub authorization_header: Option, - pub branch_filter: Option, - pub config: CreateHookOptionConfig, - pub events: Vec, - #[serde(rename = "type")] - pub _type: HookType, -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct CreateHookOptionConfig { - pub content_type: String, - pub url: Url, - #[serde(flatten)] - pub other: BTreeMap, -} - -#[derive(serde::Serialize, Debug, PartialEq, Default)] -pub struct EditHookOption { - pub active: Option, - pub authorization_header: Option, - pub branch_filter: Option, - pub config: Option>, - pub events: Option>, -} - -#[derive(Default, Debug)] -pub struct AdminOrganizationQuery { - pub page: Option, - pub limit: Option, -} - -impl AdminOrganizationQuery { - fn path(&self) -> String { - let mut s = String::from("admin/orgs?"); - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(Default, Debug)] -pub struct UnadoptedRepoQuery { - pub page: Option, - pub limit: Option, - pub pattern: String, -} - -impl UnadoptedRepoQuery { - fn path(&self) -> String { - let mut s = String::from("admin/unadopted?"); - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if !self.pattern.is_empty() { - s.push_str("pattern="); - s.push_str(&self.pattern); - s.push('&'); - } - s - } -} - -#[derive(Default, Debug)] -pub struct AdminUserQuery { - pub source_id: Option, - pub login_name: String, - pub page: Option, - pub limit: Option, -} - -impl AdminUserQuery { - fn path(&self) -> String { - let mut s = String::from("admin/users?"); - if let Some(source_id) = self.source_id { - s.push_str("source_id="); - s.write_fmt(format_args!("{source_id}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if !self.login_name.is_empty() { - s.push_str("login_name="); - s.push_str(&self.login_name); - s.push('&'); - } - if let Some(page) = self.page { - s.push_str("page="); - s.write_fmt(format_args!("{page}")) - .expect("writing to string can't fail"); - s.push('&'); - } - if let Some(limit) = self.limit { - s.push_str("limit="); - s.write_fmt(format_args!("{limit}")) - .expect("writing to string can't fail"); - s.push('&'); - } - s - } -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct CreateUserOption { - #[serde(with = "time::serde::rfc3339::option")] - pub created_at: Option, - pub email: String, - pub full_name: Option, - pub login_name: Option, - pub must_change_password: bool, - pub password: String, - pub restricted: bool, - pub send_notify: bool, - pub source_id: Option, - pub username: String, - pub visibility: String, -} - -#[derive(serde::Serialize, Debug, PartialEq, Default)] -pub struct EditUserOption { - pub active: Option, - pub admin: Option, - pub allow_create_organization: Option, - pub allow_git_hook: Option, - pub allow_import_local: Option, - pub description: Option, - pub email: Option, - pub full_name: Option, - pub location: Option, - pub login_name: Option, - pub max_repo_creation: Option, - pub must_change_password: Option, - pub password: Option, - pub prohibit_login: Option, - pub restricted: Option, - pub source_id: Option, - pub visibility: Option, - pub website: Option, -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct CreateKeyOption { - pub key: String, - pub read_only: Option, - pub title: String, -} - -#[derive(serde::Deserialize, Debug, PartialEq)] -pub struct PublicKey { - #[serde(with = "time::serde::rfc3339")] - pub created_at: time::OffsetDateTime, - pub fingerprint: String, - pub id: u64, - pub key: String, - pub key_type: String, - pub read_only: Option, - pub title: String, - pub url: Option, - pub user: User, -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct CreateOrgOption { - pub description: Option, - pub full_name: Option, - pub location: Option, - pub repo_admin_change_team_access: Option, - pub username: String, - pub visibility: OrgVisibility, - pub website: Option, -} - -#[derive(serde::Serialize, Debug, PartialEq)] -#[serde(rename_all = "lowercase")] -pub enum OrgVisibility { - Public, - Limited, - Private, -} - -#[derive(serde::Serialize, Debug, PartialEq)] -pub struct RenameUserOption { - pub new_username: String, -} diff --git a/src/generated.rs b/src/generated.rs new file mode 100644 index 0000000..0486e27 --- /dev/null +++ b/src/generated.rs @@ -0,0 +1,12253 @@ +use crate::ForgejoError; +impl crate::Forgejo { + /// Returns the Person actor for a user + /// + /// - `user-id`: user ID of the user + pub async fn activitypub_person(&self, user_id: u32) -> Result { + let request = self + .get(&format!("/activitypub/user-id/{user_id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Send to the inbox + /// + /// - `user-id`: user ID of the user + pub async fn activitypub_person_inbox(&self, user_id: u32) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/activitypub/user-id/{user_id}/inbox")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List cron tasks + /// + pub async fn admin_cron_list( + &self, + query: AdminCronListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/cron?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Run cron task + /// + /// - `task`: task to run + pub async fn admin_cron_run(&self, task: &str) -> Result<(), ForgejoError> { + let request = self.post(&format!("/admin/cron/{task}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all emails + /// + pub async fn admin_get_all_emails( + &self, + query: AdminGetAllEmailsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/emails?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search all emails + /// + pub async fn admin_search_emails( + &self, + query: AdminSearchEmailsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/emails/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List system's webhooks + /// + pub async fn admin_list_hooks( + &self, + query: AdminListHooksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/hooks?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a hook + /// + /// - `body` + pub async fn admin_create_hook(&self, body: CreateHookOption) -> Result { + let request = self.post("/admin/hooks").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a hook + /// + /// - `id`: id of the hook to get + pub async fn admin_get_hook(&self, id: u64) -> Result { + let request = self.get(&format!("/admin/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a hook + /// + /// - `id`: id of the hook to delete + pub async fn admin_delete_hook(&self, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/admin/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a hook + /// + /// - `id`: id of the hook to update + /// - `body` + pub async fn admin_edit_hook( + &self, + id: u64, + body: EditHookOption, + ) -> Result { + let request = self + .patch(&format!("/admin/hooks/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all organizations + /// + pub async fn admin_get_all_orgs( + &self, + query: AdminGetAllOrgsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/orgs?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List unadopted repositories + /// + pub async fn admin_unadopted_list( + &self, + query: AdminUnadoptedListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/unadopted?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Adopt unadopted files as a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn admin_adopt_repository( + &self, + owner: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/admin/unadopted/{owner}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete unadopted files + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn admin_delete_unadopted_repository( + &self, + owner: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/admin/unadopted/{owner}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search users according filter conditions + /// + pub async fn admin_search_users( + &self, + query: AdminSearchUsersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/admin/users?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a user + /// + /// - `body` + pub async fn admin_create_user(&self, body: CreateUserOption) -> Result { + let request = self.post("/admin/users").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a user + /// + /// - `username`: username of user to delete + pub async fn admin_delete_user( + &self, + username: &str, + query: AdminDeleteUserQuery, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/admin/users/{username}?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit an existing user + /// + /// - `username`: username of user to edit + /// - `body` + pub async fn admin_edit_user( + &self, + username: &str, + body: EditUserOption, + ) -> Result { + let request = self + .patch(&format!("/admin/users/{username}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a public key on behalf of a user + /// + /// - `username`: username of the user + /// - `key` + pub async fn admin_create_public_key( + &self, + username: &str, + key: CreateKeyOption, + ) -> Result { + let request = self + .post(&format!("/admin/users/{username}/keys")) + .json(&key) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a user's public key + /// + /// - `username`: username of user + /// - `id`: id of the key to delete + pub async fn admin_delete_user_public_key( + &self, + username: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/admin/users/{username}/keys/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create an organization + /// + /// - `username`: username of the user that will own the created organization + /// - `organization` + pub async fn admin_create_org( + &self, + username: &str, + organization: CreateOrgOption, + ) -> Result { + let request = self + .post(&format!("/admin/users/{username}/orgs")) + .json(&organization) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Rename a user + /// + /// - `username`: existing username of user + /// - `body` + pub async fn admin_rename_user( + &self, + username: &str, + body: RenameUserOption, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/admin/users/{username}/rename")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a repository on behalf of a user + /// + /// - `username`: username of the user. This user will own the created repository + /// - `repository` + pub async fn admin_create_repo( + &self, + username: &str, + repository: CreateRepoOption, + ) -> Result { + let request = self + .post(&format!("/admin/users/{username}/repos")) + .json(&repository) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns a list of all gitignore templates + pub async fn list_gitignores_templates(&self) -> Result, ForgejoError> { + let request = self.get("/gitignore/templates").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns information about a gitignore template + /// + /// - `name`: name of the template + pub async fn get_gitignore_template_info( + &self, + name: &str, + ) -> Result { + let request = self.get(&format!("/gitignore/templates/{name}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns a list of all label templates + pub async fn list_label_templates(&self) -> Result, ForgejoError> { + let request = self.get("/label/templates").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns all labels in a template + /// + /// - `name`: name of the template + pub async fn get_label_template_info( + &self, + name: &str, + ) -> Result, ForgejoError> { + let request = self.get(&format!("/label/templates/{name}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns a list of all license templates + pub async fn list_license_templates( + &self, + ) -> Result, ForgejoError> { + let request = self.get("/licenses").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns information about a license template + /// + /// - `name`: name of the license + pub async fn get_license_template_info( + &self, + name: &str, + ) -> Result { + let request = self.get(&format!("/licenses/{name}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Render a markdown document as HTML + /// + /// - `body` + pub async fn render_markdown(&self, body: MarkdownOption) -> Result { + let request = self.post("/markdown").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Render raw markdown as HTML + /// + /// - `body`: Request body to render + pub async fn render_markdown_raw(&self, body: String) -> Result { + let request = self.post("/markdown/raw").body(body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Render a markup document as HTML + /// + /// - `body` + pub async fn render_markup(&self, body: MarkupOption) -> Result { + let request = self.post("/markup").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns the nodeinfo of the Gitea application + pub async fn get_node_info(&self) -> Result { + let request = self.get("/nodeinfo").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List users's notification threads + /// + pub async fn notify_get_list( + &self, + query: NotifyGetListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/notifications?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Mark notification threads as read, pinned or unread + /// + pub async fn notify_read_list( + &self, + query: NotifyReadListQuery, + ) -> Result, ForgejoError> { + let request = self + .put(&format!("/notifications?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 205 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if unread notifications exist + pub async fn notify_new_available(&self) -> Result { + let request = self.get("/notifications/new").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get notification thread by ID + /// + /// - `id`: id of notification thread + pub async fn notify_get_thread(&self, id: &str) -> Result { + let request = self.get(&format!("/notifications/threads/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Mark notification thread as read by ID + /// + /// - `id`: id of notification thread + pub async fn notify_read_thread( + &self, + id: &str, + query: NotifyReadThreadQuery, + ) -> Result { + let request = self + .patch(&format!( + "/notifications/threads/{id}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 205 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a repository in an organization + /// + /// - `org`: name of organization + /// - `body` + pub async fn create_org_repo_deprecated( + &self, + org: &str, + body: CreateRepoOption, + ) -> Result { + let request = self + .post(&format!("/org/{org}/repos")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get list of organizations + /// + pub async fn org_get_all( + &self, + query: OrgGetAllQuery, + ) -> Result, ForgejoError> { + let request = self.get(&format!("/orgs?{}", query.to_string())).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create an organization + /// + /// - `organization` + pub async fn org_create( + &self, + organization: CreateOrgOption, + ) -> Result { + let request = self.post("/orgs").json(&organization).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get an organization + /// + /// - `org`: name of the organization to get + pub async fn org_get(&self, org: &str) -> Result { + let request = self.get(&format!("/orgs/{org}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete an organization + /// + /// - `org`: organization that is to be deleted + pub async fn org_delete(&self, org: &str) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/orgs/{org}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit an organization + /// + /// - `org`: name of the organization to edit + /// - `body` + pub async fn org_edit( + &self, + org: &str, + body: EditOrgOption, + ) -> Result { + let request = self.patch(&format!("/orgs/{org}")).json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's actions secrets + /// + /// - `org`: name of the organization + pub async fn org_list_actions_secrets( + &self, + org: &str, + query: OrgListActionsSecretsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/orgs/{org}/actions/secrets?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create or Update a secret value in an organization + /// + /// - `org`: name of organization + /// - `secretname`: name of the secret + /// - `body` + pub async fn update_org_secret( + &self, + org: &str, + secretname: &str, + body: CreateOrUpdateSecretOption, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/orgs/{org}/actions/secrets/{secretname}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(()), + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a secret in an organization + /// + /// - `org`: name of organization + /// - `secretname`: name of the secret + pub async fn delete_org_secret(&self, org: &str, secretname: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/orgs/{org}/actions/secrets/{secretname}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's activity feeds + /// + /// - `org`: name of the org + pub async fn org_list_activity_feeds( + &self, + org: &str, + query: OrgListActivityFeedsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/orgs/{org}/activities/feeds?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update Avatar + /// + /// - `org`: name of the organization + /// - `body` + pub async fn org_update_avatar( + &self, + org: &str, + body: UpdateUserAvatarOption, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/orgs/{org}/avatar")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete Avatar + /// + /// - `org`: name of the organization + pub async fn org_delete_avatar(&self, org: &str) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/orgs/{org}/avatar")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Blocks a user from the organization + /// + /// - `org`: name of the org + /// - `username`: username of the user + pub async fn org_block_user(&self, org: &str, username: &str) -> Result<(), ForgejoError> { + let request = self.put(&format!("/orgs/{org}/block/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's webhooks + /// + /// - `org`: name of the organization + pub async fn org_list_hooks( + &self, + org: &str, + query: OrgListHooksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/hooks?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a hook + /// + /// - `org`: name of the organization + /// - `body` + pub async fn org_create_hook( + &self, + org: &str, + body: CreateHookOption, + ) -> Result { + let request = self + .post(&format!("/orgs/{org}/hooks")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a hook + /// + /// - `org`: name of the organization + /// - `id`: id of the hook to get + pub async fn org_get_hook(&self, org: &str, id: u64) -> Result { + let request = self.get(&format!("/orgs/{org}/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a hook + /// + /// - `org`: name of the organization + /// - `id`: id of the hook to delete + pub async fn org_delete_hook(&self, org: &str, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/orgs/{org}/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a hook + /// + /// - `org`: name of the organization + /// - `id`: id of the hook to update + /// - `body` + pub async fn org_edit_hook( + &self, + org: &str, + id: u64, + body: EditHookOption, + ) -> Result { + let request = self + .patch(&format!("/orgs/{org}/hooks/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's labels + /// + /// - `org`: name of the organization + pub async fn org_list_labels( + &self, + org: &str, + query: OrgListLabelsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/labels?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a label for an organization + /// + /// - `org`: name of the organization + /// - `body` + pub async fn org_create_label( + &self, + org: &str, + body: CreateLabelOption, + ) -> Result { + let request = self + .post(&format!("/orgs/{org}/labels")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a single label + /// + /// - `org`: name of the organization + /// - `id`: id of the label to get + pub async fn org_get_label(&self, org: &str, id: u64) -> Result { + let request = self.get(&format!("/orgs/{org}/labels/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a label + /// + /// - `org`: name of the organization + /// - `id`: id of the label to delete + pub async fn org_delete_label(&self, org: &str, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/orgs/{org}/labels/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a label + /// + /// - `org`: name of the organization + /// - `id`: id of the label to edit + /// - `body` + pub async fn org_edit_label( + &self, + org: &str, + id: u64, + body: EditLabelOption, + ) -> Result { + let request = self + .patch(&format!("/orgs/{org}/labels/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the organization's blocked users + /// + /// - `org`: name of the org + pub async fn org_list_blocked_users( + &self, + org: &str, + query: OrgListBlockedUsersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/list_blocked?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's members + /// + /// - `org`: name of the organization + pub async fn org_list_members( + &self, + org: &str, + query: OrgListMembersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/members?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if a user is a member of an organization + /// + /// - `org`: name of the organization + /// - `username`: username of the user + pub async fn org_is_member(&self, org: &str, username: &str) -> Result<(), ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a member from an organization + /// + /// - `org`: name of the organization + /// - `username`: username of the user + pub async fn org_delete_member(&self, org: &str, username: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/orgs/{org}/members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's public members + /// + /// - `org`: name of the organization + pub async fn org_list_public_members( + &self, + org: &str, + query: OrgListPublicMembersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/public_members?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if a user is a public member of an organization + /// + /// - `org`: name of the organization + /// - `username`: username of the user + pub async fn org_is_public_member( + &self, + org: &str, + username: &str, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/public_members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Publicize a user's membership + /// + /// - `org`: name of the organization + /// - `username`: username of the user + pub async fn org_publicize_member( + &self, + org: &str, + username: &str, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/orgs/{org}/public_members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Conceal a user's membership + /// + /// - `org`: name of the organization + /// - `username`: username of the user + pub async fn org_conceal_member(&self, org: &str, username: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/orgs/{org}/public_members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's repos + /// + /// - `org`: name of the organization + pub async fn org_list_repos( + &self, + org: &str, + query: OrgListReposQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/repos?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a repository in an organization + /// + /// - `org`: name of organization + /// - `body` + pub async fn create_org_repo( + &self, + org: &str, + body: CreateRepoOption, + ) -> Result { + let request = self + .post(&format!("/orgs/{org}/repos")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an organization's teams + /// + /// - `org`: name of the organization + pub async fn org_list_teams( + &self, + org: &str, + query: OrgListTeamsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/teams?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a team + /// + /// - `org`: name of the organization + /// - `body` + pub async fn org_create_team( + &self, + org: &str, + body: CreateTeamOption, + ) -> Result { + let request = self + .post(&format!("/orgs/{org}/teams")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search for teams within an organization + /// + /// - `org`: name of the organization + pub async fn team_search( + &self, + org: &str, + query: TeamSearchQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/orgs/{org}/teams/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unblock a user from the organization + /// + /// - `org`: name of the org + /// - `username`: username of the user + pub async fn org_unblock_user(&self, org: &str, username: &str) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/orgs/{org}/unblock/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets all packages of an owner + /// + /// - `owner`: owner of the packages + pub async fn list_packages( + &self, + owner: &str, + query: ListPackagesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/packages/{owner}?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets a package + /// + /// - `owner`: owner of the package + /// - `type`: type of the package + /// - `name`: name of the package + /// - `version`: version of the package + pub async fn get_package( + &self, + owner: &str, + r#type: &str, + name: &str, + version: &str, + ) -> Result { + let request = self + .get(&format!("/packages/{owner}/{type}/{name}/{version}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a package + /// + /// - `owner`: owner of the package + /// - `type`: type of the package + /// - `name`: name of the package + /// - `version`: version of the package + pub async fn delete_package( + &self, + owner: &str, + r#type: &str, + name: &str, + version: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/packages/{owner}/{type}/{name}/{version}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets all files of a package + /// + /// - `owner`: owner of the package + /// - `type`: type of the package + /// - `name`: name of the package + /// - `version`: version of the package + pub async fn list_package_files( + &self, + owner: &str, + r#type: &str, + name: &str, + version: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/packages/{owner}/{type}/{name}/{version}/files")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search for issues across the repositories that the user has access to + /// + pub async fn issue_search_issues( + &self, + query: IssueSearchIssuesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/issues/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Migrate a remote git repository + /// + /// - `body` + pub async fn repo_migrate(&self, body: MigrateRepoOptions) -> Result { + let request = self.post("/repos/migrate").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search for repositories + /// + pub async fn repo_search(&self, query: RepoSearchQuery) -> Result { + let request = self + .get(&format!("/repos/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get(&self, owner: &str, repo: &str) -> Result { + let request = self.get(&format!("/repos/{owner}/{repo}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a repository + /// + /// - `owner`: owner of the repo to delete + /// - `repo`: name of the repo to delete + pub async fn repo_delete(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/repos/{owner}/{repo}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a repository's properties. Only fields that are set will be changed. + /// + /// - `owner`: owner of the repo to edit + /// - `repo`: name of the repo to edit + /// - `body`: Properties of a repo that you can edit + pub async fn repo_edit( + &self, + owner: &str, + repo: &str, + body: EditRepoOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create or Update a secret value in a repository + /// + /// - `owner`: owner of the repository + /// - `repo`: name of the repository + /// - `secretname`: name of the secret + /// - `body` + pub async fn update_repo_secret( + &self, + owner: &str, + repo: &str, + secretname: &str, + body: CreateOrUpdateSecretOption, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!( + "/repos/{owner}/{repo}/actions/secrets/{secretname}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(()), + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a secret in a repository + /// + /// - `owner`: owner of the repository + /// - `repo`: name of the repository + /// - `secretname`: name of the secret + pub async fn delete_repo_secret( + &self, + owner: &str, + repo: &str, + secretname: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/actions/secrets/{secretname}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's activity feeds + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_activity_feeds( + &self, + owner: &str, + repo: &str, + query: RepoListActivityFeedsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/activities/feeds?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get an archive of a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `archive`: the git reference for download with attached archive format (e.g. master.zip) + pub async fn repo_get_archive( + &self, + owner: &str, + repo: &str, + archive: &str, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/archive/{archive}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Return all users that have write access and can be assigned to issues + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_assignees( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/assignees")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update avatar + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_update_avatar( + &self, + owner: &str, + repo: &str, + body: UpdateRepoAvatarOption, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/avatar")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete avatar + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_delete_avatar(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/avatar")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List branch protections for a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_branch_protection( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/branch_protections")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a branch protections for a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_branch_protection( + &self, + owner: &str, + repo: &str, + body: CreateBranchProtectionOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/branch_protections")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a specific branch protection for the repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `name`: name of protected branch + pub async fn repo_get_branch_protection( + &self, + owner: &str, + repo: &str, + name: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/branch_protections/{name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a specific branch protection for the repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `name`: name of protected branch + pub async fn repo_delete_branch_protection( + &self, + owner: &str, + repo: &str, + name: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/branch_protections/{name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a branch protections for a repository. Only fields that are set will be changed + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `name`: name of protected branch + /// - `body` + pub async fn repo_edit_branch_protection( + &self, + owner: &str, + repo: &str, + name: &str, + body: EditBranchProtectionOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/branch_protections/{name}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's branches + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_branches( + &self, + owner: &str, + repo: &str, + query: RepoListBranchesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/branches?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a branch + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_branch( + &self, + owner: &str, + repo: &str, + body: CreateBranchRepoOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/branches")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Retrieve a specific branch from a repository, including its effective branch protection + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `branch`: branch to get + pub async fn repo_get_branch( + &self, + owner: &str, + repo: &str, + branch: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/branches/{branch}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a specific branch from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `branch`: branch to delete + pub async fn repo_delete_branch( + &self, + owner: &str, + repo: &str, + branch: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/branches/{branch}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's collaborators + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_collaborators( + &self, + owner: &str, + repo: &str, + query: RepoListCollaboratorsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/collaborators?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if a user is a collaborator of a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `collaborator`: username of the collaborator + pub async fn repo_check_collaborator( + &self, + owner: &str, + repo: &str, + collaborator: &str, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/collaborators/{collaborator}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a collaborator to a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `collaborator`: username of the collaborator to add + /// - `body` + pub async fn repo_add_collaborator( + &self, + owner: &str, + repo: &str, + collaborator: &str, + body: AddCollaboratorOption, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!( + "/repos/{owner}/{repo}/collaborators/{collaborator}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a collaborator from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `collaborator`: username of the collaborator to delete + pub async fn repo_delete_collaborator( + &self, + owner: &str, + repo: &str, + collaborator: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/collaborators/{collaborator}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get repository permissions for a user + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `collaborator`: username of the collaborator + pub async fn repo_get_repo_permissions( + &self, + owner: &str, + repo: &str, + collaborator: &str, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/collaborators/{collaborator}/permission" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a list of all commits from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_all_commits( + &self, + owner: &str, + repo: &str, + query: RepoGetAllCommitsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/commits?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a commit's combined status, by branch/tag/commit reference + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `ref`: name of branch/tag/commit + pub async fn repo_get_combined_status_by_ref( + &self, + owner: &str, + repo: &str, + r#ref: &str, + query: RepoGetCombinedStatusByRefQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/commits/{ref}/status?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a commit's statuses, by branch/tag/commit reference + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `ref`: name of branch/tag/commit + pub async fn repo_list_statuses_by_ref( + &self, + owner: &str, + repo: &str, + r#ref: &str, + query: RepoListStatusesByRefQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/commits/{ref}/statuses?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the metadata of all the entries of the root dir + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_contents_list( + &self, + owner: &str, + repo: &str, + query: RepoGetContentsListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/contents?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Modify multiple files in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_change_files( + &self, + owner: &str, + repo: &str, + body: ChangeFilesOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/contents")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: path of the dir, file, symlink or submodule in the repo + pub async fn repo_get_contents( + &self, + owner: &str, + repo: &str, + filepath: &str, + query: RepoGetContentsQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/contents/{filepath}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a file in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: path of the file to update + /// - `body` + pub async fn repo_update_file( + &self, + owner: &str, + repo: &str, + filepath: &str, + body: UpdateFileOptions, + ) -> Result { + let request = self + .put(&format!("/repos/{owner}/{repo}/contents/{filepath}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a file in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: path of the file to create + /// - `body` + pub async fn repo_create_file( + &self, + owner: &str, + repo: &str, + filepath: &str, + body: CreateFileOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/contents/{filepath}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a file in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: path of the file to delete + /// - `body` + pub async fn repo_delete_file( + &self, + owner: &str, + repo: &str, + filepath: &str, + body: DeleteFileOptions, + ) -> Result { + let request = self + .delete(&format!("/repos/{owner}/{repo}/contents/{filepath}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Apply diff patch to repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_apply_diff_patch( + &self, + owner: &str, + repo: &str, + body: UpdateFileOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/diffpatch")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get the EditorConfig definitions of a file in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: filepath of file to get + pub async fn repo_get_editor_config( + &self, + owner: &str, + repo: &str, + filepath: &str, + query: RepoGetEditorConfigQuery, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/editorconfig/{filepath}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's forks + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn list_forks( + &self, + owner: &str, + repo: &str, + query: ListForksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/forks?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Fork a repository + /// + /// - `owner`: owner of the repo to fork + /// - `repo`: name of the repo to fork + /// - `body` + pub async fn create_fork( + &self, + owner: &str, + repo: &str, + body: CreateForkOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/forks")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 202 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the blob of a repository. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: sha of the commit + pub async fn get_blob( + &self, + owner: &str, + repo: &str, + sha: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/git/blobs/{sha}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a single commit from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: a git ref or commit sha + pub async fn repo_get_single_commit( + &self, + owner: &str, + repo: &str, + sha: &str, + query: RepoGetSingleCommitQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/git/commits/{sha}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a commit's diff or patch + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: SHA of the commit to get + /// - `diffType`: whether the output is diff or patch + pub async fn repo_download_commit_diff_or_patch( + &self, + owner: &str, + repo: &str, + sha: &str, + diff_type: &str, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/git/commits/{sha}.{diff_type}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a note corresponding to a single commit from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: a git ref or commit sha + pub async fn repo_get_note( + &self, + owner: &str, + repo: &str, + sha: &str, + query: RepoGetNoteQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/git/notes/{sha}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get specified ref or filtered repository's refs + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_all_git_refs( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/git/refs")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get specified ref or filtered repository's refs + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `ref`: part or full name of the ref + pub async fn repo_list_git_refs( + &self, + owner: &str, + repo: &str, + r#ref: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/git/refs/{ref}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the tag object of an annotated tag (not lightweight tags) + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: sha of the tag. The Git tags API only supports annotated tag objects, not lightweight tags. + pub async fn get_annotated_tag( + &self, + owner: &str, + repo: &str, + sha: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/git/tags/{sha}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the tree of a repository. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: sha of the commit + pub async fn get_tree( + &self, + owner: &str, + repo: &str, + sha: &str, + query: GetTreeQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/git/trees/{sha}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the hooks in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_hooks( + &self, + owner: &str, + repo: &str, + query: RepoListHooksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/hooks?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a hook + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_hook( + &self, + owner: &str, + repo: &str, + body: CreateHookOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/hooks")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the Git hooks in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_git_hooks( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/hooks/git")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a Git hook + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to get + pub async fn repo_get_git_hook( + &self, + owner: &str, + repo: &str, + id: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/hooks/git/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a Git hook in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to get + pub async fn repo_delete_git_hook( + &self, + owner: &str, + repo: &str, + id: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/hooks/git/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a Git hook in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to get + /// - `body` + pub async fn repo_edit_git_hook( + &self, + owner: &str, + repo: &str, + id: &str, + body: EditGitHookOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/hooks/git/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a hook + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to get + pub async fn repo_get_hook( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/hooks/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a hook in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to delete + pub async fn repo_delete_hook( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/hooks/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a hook in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: index of the hook + /// - `body` + pub async fn repo_edit_hook( + &self, + owner: &str, + repo: &str, + id: u64, + body: EditHookOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/hooks/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Test a push webhook + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the hook to test + pub async fn repo_test_hook( + &self, + owner: &str, + repo: &str, + id: u64, + query: RepoTestHookQuery, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/hooks/{id}/tests?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns the issue config for a repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_issue_config( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/issue_config")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns the validation information for a issue config + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_validate_issue_config( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/issue_config/validate")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get available issue templates for a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_issue_templates( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/issue_templates")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's issues + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn issue_list_issues( + &self, + owner: &str, + repo: &str, + query: IssueListIssuesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create an issue. If using deadline only the date will be taken into account, and time of day ignored. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn issue_create_issue( + &self, + owner: &str, + repo: &str, + body: CreateIssueOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all comments in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn issue_get_repo_comments( + &self, + owner: &str, + repo: &str, + query: IssueGetRepoCommentsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/comments?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a comment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + pub async fn issue_get_comment( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/issues/comments/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(Some(response.json().await?)), + 204 => Ok(None), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a comment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of comment to delete + pub async fn issue_delete_comment( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/comments/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a comment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment to edit + /// - `body` + pub async fn issue_edit_comment( + &self, + owner: &str, + repo: &str, + id: u64, + body: EditIssueCommentOption, + ) -> Result, ForgejoError> { + let request = self + .patch(&format!("/repos/{owner}/{repo}/issues/comments/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(Some(response.json().await?)), + 204 => Ok(None), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List comment's attachments + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + pub async fn issue_list_issue_comment_attachments( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/assets" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a comment attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + /// - `attachment`: attachment to upload + pub async fn issue_create_issue_comment_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment: Vec, + query: IssueCreateIssueCommentAttachmentQuery, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/assets?{}", + query.to_string() + )) + .multipart( + reqwest::multipart::Form::new().part( + "attachment", + reqwest::multipart::Part::bytes(attachment) + .file_name("file") + .mime_str("*/*") + .unwrap(), + ), + ) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a comment attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + /// - `attachment_id`: id of the attachment to get + pub async fn issue_get_issue_comment_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a comment attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + /// - `attachment_id`: id of the attachment to delete + pub async fn issue_delete_issue_comment_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a comment attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment + /// - `attachment_id`: id of the attachment to edit + /// - `body` + pub async fn issue_edit_issue_comment_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + body: EditAttachmentOptions, + ) -> Result { + let request = self + .patch(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a list of reactions from a comment of an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment to edit + pub async fn issue_get_comment_reactions( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/reactions" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a reaction to a comment of an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment to edit + /// - `content` + pub async fn issue_post_comment_reaction( + &self, + owner: &str, + repo: &str, + id: u64, + content: EditReactionOption, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/reactions" + )) + .json(&content) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a reaction from a comment of an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the comment to edit + /// - `content` + pub async fn issue_delete_comment_reaction( + &self, + owner: &str, + repo: &str, + id: u64, + content: EditReactionOption, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/comments/{id}/reactions" + )) + .json(&content) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's pinned issues + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_pinned_issues( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/issues/pinned")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to get + pub async fn issue_get_issue( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/issues/{index}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of issue to delete + pub async fn issue_delete( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit an issue. If using deadline only the date will be taken into account, and time of day ignored. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to edit + /// - `body` + pub async fn issue_edit_issue( + &self, + owner: &str, + repo: &str, + index: u64, + body: EditIssueOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/issues/{index}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List issue's attachments + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_list_issue_attachments( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/issues/{index}/assets")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create an issue attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `attachment`: attachment to upload + pub async fn issue_create_issue_attachment( + &self, + owner: &str, + repo: &str, + index: u64, + attachment: Vec, + query: IssueCreateIssueAttachmentQuery, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/{index}/assets?{}", + query.to_string() + )) + .multipart( + reqwest::multipart::Form::new().part( + "attachment", + reqwest::multipart::Part::bytes(attachment) + .file_name("file") + .mime_str("*/*") + .unwrap(), + ), + ) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get an issue attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `attachment_id`: id of the attachment to get + pub async fn issue_get_issue_attachment( + &self, + owner: &str, + repo: &str, + index: u64, + attachment_id: u64, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete an issue attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `attachment_id`: id of the attachment to delete + pub async fn issue_delete_issue_attachment( + &self, + owner: &str, + repo: &str, + index: u64, + attachment_id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit an issue attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `attachment_id`: id of the attachment to edit + /// - `body` + pub async fn issue_edit_issue_attachment( + &self, + owner: &str, + repo: &str, + index: u64, + attachment_id: u64, + body: EditAttachmentOptions, + ) -> Result { + let request = self + .patch(&format!( + "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List issues that are blocked by this issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_list_blocks( + &self, + owner: &str, + repo: &str, + index: &str, + query: IssueListBlocksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/blocks?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Block the issue given in the body by the issue in path + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_create_issue_blocking( + &self, + owner: &str, + repo: &str, + index: &str, + body: IssueMeta, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/blocks")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unblock the issue given in the body by the issue in path + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_remove_issue_blocking( + &self, + owner: &str, + repo: &str, + index: &str, + body: IssueMeta, + ) -> Result { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/blocks")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all comments on an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_get_comments( + &self, + owner: &str, + repo: &str, + index: u64, + query: IssueGetCommentsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/comments?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a comment to an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_create_comment( + &self, + owner: &str, + repo: &str, + index: u64, + body: CreateIssueCommentOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/comments")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a comment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: this parameter is ignored + /// - `id`: id of comment to delete + pub async fn issue_delete_comment_deprecated( + &self, + owner: &str, + repo: &str, + index: u32, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/{index}/comments/{id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a comment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: this parameter is ignored + /// - `id`: id of the comment to edit + /// - `body` + pub async fn issue_edit_comment_deprecated( + &self, + owner: &str, + repo: &str, + index: u32, + id: u64, + body: EditIssueCommentOption, + ) -> Result, ForgejoError> { + let request = self + .patch(&format!( + "/repos/{owner}/{repo}/issues/{index}/comments/{id}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(Some(response.json().await?)), + 204 => Ok(None), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to create or update a deadline on + /// - `body` + pub async fn issue_edit_issue_deadline( + &self, + owner: &str, + repo: &str, + index: u64, + body: EditDeadlineOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/deadline")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an issue's dependencies, i.e all issues that block this issue. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_list_issue_dependencies( + &self, + owner: &str, + repo: &str, + index: &str, + query: IssueListIssueDependenciesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/dependencies?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Make the issue in the url depend on the issue in the form. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_create_issue_dependencies( + &self, + owner: &str, + repo: &str, + index: &str, + body: IssueMeta, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/{index}/dependencies" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove an issue dependency + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_remove_issue_dependencies( + &self, + owner: &str, + repo: &str, + index: &str, + body: IssueMeta, + ) -> Result { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/{index}/dependencies" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get an issue's labels + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_get_labels( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/issues/{index}/labels")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Replace an issue's labels + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_replace_labels( + &self, + owner: &str, + repo: &str, + index: u64, + body: IssueLabelsOption, + ) -> Result, ForgejoError> { + let request = self + .put(&format!("/repos/{owner}/{repo}/issues/{index}/labels")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a label to an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_add_label( + &self, + owner: &str, + repo: &str, + index: u64, + body: IssueLabelsOption, + ) -> Result, ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/labels")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove all labels from an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_clear_labels( + &self, + owner: &str, + repo: &str, + index: u64, + body: DeleteLabelsOption, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/labels")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a label from an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `id`: id of the label to remove + /// - `body` + pub async fn issue_remove_label( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + body: DeleteLabelsOption, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/labels/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Pin an Issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of issue to pin + pub async fn pin_issue(&self, owner: &str, repo: &str, index: u64) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/pin")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unpin an Issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of issue to unpin + pub async fn unpin_issue( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/pin")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Moves the Pin to the given Position + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of issue + /// - `position`: the new position + pub async fn move_issue_pin( + &self, + owner: &str, + repo: &str, + index: u64, + position: u64, + ) -> Result<(), ForgejoError> { + let request = self + .patch(&format!( + "/repos/{owner}/{repo}/issues/{index}/pin/{position}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a list reactions of an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_get_issue_reactions( + &self, + owner: &str, + repo: &str, + index: u64, + query: IssueGetIssueReactionsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/reactions?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a reaction to an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `content` + pub async fn issue_post_issue_reaction( + &self, + owner: &str, + repo: &str, + index: u64, + content: EditReactionOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/reactions")) + .json(&content) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a reaction from an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `content` + pub async fn issue_delete_issue_reaction( + &self, + owner: &str, + repo: &str, + index: u64, + content: EditReactionOption, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/reactions")) + .json(&content) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete an issue's existing stopwatch. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to stop the stopwatch on + pub async fn issue_delete_stop_watch( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/{index}/stopwatch/delete" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Start stopwatch on an issue. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to create the stopwatch on + pub async fn issue_start_stop_watch( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/{index}/stopwatch/start" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Stop an issue's existing stopwatch. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to stop the stopwatch on + pub async fn issue_stop_stop_watch( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/issues/{index}/stopwatch/stop" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get users who subscribed on an issue. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_subscriptions( + &self, + owner: &str, + repo: &str, + index: u64, + query: IssueSubscriptionsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/subscriptions?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if user is subscribed to an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_check_subscription( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/subscriptions/check" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Subscribe user to issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `user`: user to subscribe + pub async fn issue_add_subscription( + &self, + owner: &str, + repo: &str, + index: u64, + user: &str, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!( + "/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + 201 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unsubscribe user from issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `user`: user witch unsubscribe + pub async fn issue_delete_subscription( + &self, + owner: &str, + repo: &str, + index: u64, + user: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + 201 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all comments and events on an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_get_comments_and_timeline( + &self, + owner: &str, + repo: &str, + index: u64, + query: IssueGetCommentsAndTimelineQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/timeline?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List an issue's tracked times + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + pub async fn issue_tracked_times( + &self, + owner: &str, + repo: &str, + index: u64, + query: IssueTrackedTimesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/issues/{index}/times?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add tracked time to a issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `body` + pub async fn issue_add_time( + &self, + owner: &str, + repo: &str, + index: u64, + body: AddTimeOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/issues/{index}/times")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Reset a tracked time of an issue + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue to add tracked time to + pub async fn issue_reset_time( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/times")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete specific tracked time + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the issue + /// - `id`: id of time to delete + pub async fn issue_delete_time( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/issues/{index}/times/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's keys + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_keys( + &self, + owner: &str, + repo: &str, + query: RepoListKeysQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/keys?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a key to a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_key( + &self, + owner: &str, + repo: &str, + body: CreateKeyOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/keys")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a repository's key by id + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the key to get + pub async fn repo_get_key( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/keys/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a key from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the key to delete + pub async fn repo_delete_key( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/keys/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get all of a repository's labels + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn issue_list_labels( + &self, + owner: &str, + repo: &str, + query: IssueListLabelsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/labels?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a label + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn issue_create_label( + &self, + owner: &str, + repo: &str, + body: CreateLabelOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/labels")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a single label + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the label to get + pub async fn issue_get_label( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/labels/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a label + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the label to delete + pub async fn issue_delete_label( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/labels/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a label + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the label to edit + /// - `body` + pub async fn issue_edit_label( + &self, + owner: &str, + repo: &str, + id: u64, + body: EditLabelOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/labels/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get languages and number of bytes of code written + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_languages( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/languages")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a file or it's LFS object from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: filepath of the file to get + pub async fn repo_get_raw_file_or_lfs( + &self, + owner: &str, + repo: &str, + filepath: &str, + query: RepoGetRawFileOrLfsQuery, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/media/{filepath}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get all of a repository's opened milestones + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn issue_get_milestones_list( + &self, + owner: &str, + repo: &str, + query: IssueGetMilestonesListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/milestones?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a milestone + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn issue_create_milestone( + &self, + owner: &str, + repo: &str, + body: CreateMilestoneOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/milestones")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a milestone + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: the milestone to get, identified by ID and if not available by name + pub async fn issue_get_milestone( + &self, + owner: &str, + repo: &str, + id: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/milestones/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a milestone + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: the milestone to delete, identified by ID and if not available by name + pub async fn issue_delete_milestone( + &self, + owner: &str, + repo: &str, + id: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/milestones/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a milestone + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: the milestone to edit, identified by ID and if not available by name + /// - `body` + pub async fn issue_edit_milestone( + &self, + owner: &str, + repo: &str, + id: &str, + body: EditMilestoneOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/milestones/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Sync a mirrored repository + /// + /// - `owner`: owner of the repo to sync + /// - `repo`: name of the repo to sync + pub async fn repo_mirror_sync(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/mirror-sync")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns if new Issue Pins are allowed + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_new_pin_allowed( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/new_pin_allowed")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List users's notification threads on a specific repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn notify_get_repo_list( + &self, + owner: &str, + repo: &str, + query: NotifyGetRepoListQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/notifications?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Mark notification threads as read, pinned or unread on a specific repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn notify_read_repo_list( + &self, + owner: &str, + repo: &str, + query: NotifyReadRepoListQuery, + ) -> Result, ForgejoError> { + let request = self + .put(&format!( + "/repos/{owner}/{repo}/notifications?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 205 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's pull requests + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_pull_requests( + &self, + owner: &str, + repo: &str, + query: RepoListPullRequestsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_pull_request( + &self, + owner: &str, + repo: &str, + body: CreatePullRequestOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/pulls")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's pinned pull requests + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_pinned_pull_requests( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/pulls/pinned")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to get + pub async fn repo_get_pull_request( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/pulls/{index}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a pull request. If using deadline only the date will be taken into account, and time of day ignored. + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to edit + /// - `body` + pub async fn repo_edit_pull_request( + &self, + owner: &str, + repo: &str, + index: u64, + body: EditPullRequestOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/pulls/{index}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a pull request diff or patch + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to get + /// - `diffType`: whether the output is diff or patch + pub async fn repo_download_pull_diff_or_patch( + &self, + owner: &str, + repo: &str, + index: u64, + diff_type: &str, + query: RepoDownloadPullDiffOrPatchQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls/{index}.{diff_type}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get commits for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to get + pub async fn repo_get_pull_request_commits( + &self, + owner: &str, + repo: &str, + index: u64, + query: RepoGetPullRequestCommitsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls/{index}/commits?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get changed files for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to get + pub async fn repo_get_pull_request_files( + &self, + owner: &str, + repo: &str, + index: u64, + query: RepoGetPullRequestFilesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls/{index}/files?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if a pull request has been merged + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + pub async fn repo_pull_request_is_merged( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/pulls/{index}/merge")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Merge a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to merge + /// - `body` + pub async fn repo_merge_pull_request( + &self, + owner: &str, + repo: &str, + index: u64, + body: MergePullRequestOption, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/pulls/{index}/merge")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Cancel the scheduled auto merge for the given pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to merge + pub async fn repo_cancel_scheduled_auto_merge( + &self, + owner: &str, + repo: &str, + index: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/pulls/{index}/merge")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// create review requests for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `body` + pub async fn repo_create_pull_review_requests( + &self, + owner: &str, + repo: &str, + index: u64, + body: PullReviewRequestOptions, + ) -> Result, ForgejoError> { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/pulls/{index}/requested_reviewers" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// cancel review requests for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `body` + pub async fn repo_delete_pull_review_requests( + &self, + owner: &str, + repo: &str, + index: u64, + body: PullReviewRequestOptions, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/pulls/{index}/requested_reviewers" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all reviews for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + pub async fn repo_list_pull_reviews( + &self, + owner: &str, + repo: &str, + index: u64, + query: RepoListPullReviewsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls/{index}/reviews?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a review to an pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `body` + pub async fn repo_create_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + body: CreatePullReviewOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/pulls/{index}/reviews")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a specific review for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + pub async fn repo_get_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/pulls/{index}/reviews/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Submit a pending review to an pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + /// - `body` + pub async fn repo_submit_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + body: SubmitPullReviewOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/pulls/{index}/reviews/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a specific review from a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + pub async fn repo_delete_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/pulls/{index}/reviews/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a specific review for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + pub async fn repo_get_pull_review_comments( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/pulls/{index}/reviews/{id}/comments" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Dismiss a review for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + /// - `body` + pub async fn repo_dismiss_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + body: DismissPullReviewOptions, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/pulls/{index}/reviews/{id}/dismissals" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Cancel to dismiss a review for a pull request + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request + /// - `id`: id of the review + pub async fn repo_un_dismiss_pull_review( + &self, + owner: &str, + repo: &str, + index: u64, + id: u64, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/pulls/{index}/reviews/{id}/undismissals" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Merge PR's baseBranch into headBranch + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `index`: index of the pull request to get + pub async fn repo_update_pull_request( + &self, + owner: &str, + repo: &str, + index: u64, + query: RepoUpdatePullRequestQuery, + ) -> Result<(), ForgejoError> { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/pulls/{index}/update?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get all push mirrors of the repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_push_mirrors( + &self, + owner: &str, + repo: &str, + query: RepoListPushMirrorsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/push_mirrors?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// add a push mirror to the repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_add_push_mirror( + &self, + owner: &str, + repo: &str, + body: CreatePushMirrorOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/push_mirrors")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Sync all push mirrored repository + /// + /// - `owner`: owner of the repo to sync + /// - `repo`: name of the repo to sync + pub async fn repo_push_mirror_sync(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { + let request = self + .post(&format!("/repos/{owner}/{repo}/push_mirrors-sync")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get push mirror of the repository by remoteName + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `name`: remote name of push mirror + pub async fn repo_get_push_mirror_by_remote_name( + &self, + owner: &str, + repo: &str, + name: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/push_mirrors/{name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// deletes a push mirror from a repository by remoteName + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `name`: remote name of the pushMirror + pub async fn repo_delete_push_mirror( + &self, + owner: &str, + repo: &str, + name: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/push_mirrors/{name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a file from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `filepath`: filepath of the file to get + pub async fn repo_get_raw_file( + &self, + owner: &str, + repo: &str, + filepath: &str, + query: RepoGetRawFileQuery, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/raw/{filepath}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's releases + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_releases( + &self, + owner: &str, + repo: &str, + query: RepoListReleasesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/releases?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a release + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_release( + &self, + owner: &str, + repo: &str, + body: CreateReleaseOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/releases")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Gets the most recent non-prerelease, non-draft release of a repository, sorted by created_at + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_latest_release( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/releases/latest")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a release by tag name + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `tag`: tag name of the release to get + pub async fn repo_get_release_by_tag( + &self, + owner: &str, + repo: &str, + tag: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/releases/tags/{tag}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a release by tag name + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `tag`: tag name of the release to delete + pub async fn repo_delete_release_by_tag( + &self, + owner: &str, + repo: &str, + tag: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/releases/tags/{tag}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a release + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release to get + pub async fn repo_get_release( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/releases/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a release + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release to delete + pub async fn repo_delete_release( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/releases/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a release + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release to edit + /// - `body` + pub async fn repo_edit_release( + &self, + owner: &str, + repo: &str, + id: u64, + body: EditReleaseOption, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/releases/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List release's attachments + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release + pub async fn repo_list_release_attachments( + &self, + owner: &str, + repo: &str, + id: u64, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/releases/{id}/assets")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a release attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release + /// - `attachment`: attachment to upload + pub async fn repo_create_release_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment: Vec, + query: RepoCreateReleaseAttachmentQuery, + ) -> Result { + let request = self + .post(&format!( + "/repos/{owner}/{repo}/releases/{id}/assets?{}", + query.to_string() + )) + .multipart( + reqwest::multipart::Form::new().part( + "attachment", + reqwest::multipart::Part::bytes(attachment) + .file_name("file") + .mime_str("*/*") + .unwrap(), + ), + ) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a release attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release + /// - `attachment_id`: id of the attachment to get + pub async fn repo_get_release_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a release attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release + /// - `attachment_id`: id of the attachment to delete + pub async fn repo_delete_release_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!( + "/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}" + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a release attachment + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `id`: id of the release + /// - `attachment_id`: id of the attachment to edit + /// - `body` + pub async fn repo_edit_release_attachment( + &self, + owner: &str, + repo: &str, + id: u64, + attachment_id: u64, + body: EditAttachmentOptions, + ) -> Result { + let request = self + .patch(&format!( + "/repos/{owner}/{repo}/releases/{id}/assets/{attachment_id}" + )) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Return all users that can be requested to review in this repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_reviewers( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/reviewers")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get signing-key.gpg for given repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_signing_key(&self, owner: &str, repo: &str) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/signing-key.gpg")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's stargazers + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_stargazers( + &self, + owner: &str, + repo: &str, + query: RepoListStargazersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/stargazers?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a commit's statuses + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: sha of the commit + pub async fn repo_list_statuses( + &self, + owner: &str, + repo: &str, + sha: &str, + query: RepoListStatusesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/statuses/{sha}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a commit status + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `sha`: sha of the commit + /// - `body` + pub async fn repo_create_status( + &self, + owner: &str, + repo: &str, + sha: &str, + body: CreateStatusOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/statuses/{sha}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's watchers + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_subscribers( + &self, + owner: &str, + repo: &str, + query: RepoListSubscribersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/subscribers?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if the current user is watching a repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn user_current_check_subscription( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/subscription")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Watch a repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn user_current_put_subscription( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .put(&format!("/repos/{owner}/{repo}/subscription")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unwatch a repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn user_current_delete_subscription( + &self, + owner: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/subscription")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's tags + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_tags( + &self, + owner: &str, + repo: &str, + query: RepoListTagsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/tags?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a new git tag in a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_tag( + &self, + owner: &str, + repo: &str, + body: CreateTagOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/tags")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get the tag of a repository by tag name + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `tag`: name of tag + pub async fn repo_get_tag( + &self, + owner: &str, + repo: &str, + tag: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/tags/{tag}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a repository's tag by name + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `tag`: name of tag to delete + pub async fn repo_delete_tag( + &self, + owner: &str, + repo: &str, + tag: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/tags/{tag}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repository's teams + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_teams( + &self, + owner: &str, + repo: &str, + ) -> Result, ForgejoError> { + let request = self.get(&format!("/repos/{owner}/{repo}/teams")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if a team is assigned to a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `team`: team name + pub async fn repo_check_team( + &self, + owner: &str, + repo: &str, + team: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/teams/{team}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a team to a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `team`: team name + pub async fn repo_add_team( + &self, + owner: &str, + repo: &str, + team: &str, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/repos/{owner}/{repo}/teams/{team}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a team from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `team`: team name + pub async fn repo_delete_team( + &self, + owner: &str, + repo: &str, + team: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/teams/{team}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a repo's tracked times + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_tracked_times( + &self, + owner: &str, + repo: &str, + query: RepoTrackedTimesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/times?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a user's tracked times in a repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `user`: username of user + pub async fn user_tracked_times( + &self, + owner: &str, + repo: &str, + user: &str, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/repos/{owner}/{repo}/times/{user}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get list of topics that a repository has + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_list_topics( + &self, + owner: &str, + repo: &str, + query: RepoListTopicsQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/topics?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Replace list of topics for a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_update_topics( + &self, + owner: &str, + repo: &str, + body: RepoTopicOptions, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/repos/{owner}/{repo}/topics")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a topic to a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `topic`: name of the topic to add + pub async fn repo_add_topic( + &self, + owner: &str, + repo: &str, + topic: &str, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/repos/{owner}/{repo}/topics/{topic}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a topic from a repository + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `topic`: name of the topic to delete + pub async fn repo_delete_topic( + &self, + owner: &str, + repo: &str, + topic: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/topics/{topic}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Transfer a repo ownership + /// + /// - `owner`: owner of the repo to transfer + /// - `repo`: name of the repo to transfer + /// - `body`: Transfer Options + pub async fn repo_transfer( + &self, + owner: &str, + repo: &str, + body: TransferRepoOption, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/transfer")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 202 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Accept a repo transfer + /// + /// - `owner`: owner of the repo to transfer + /// - `repo`: name of the repo to transfer + pub async fn accept_repo_transfer( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/transfer/accept")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 202 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Reject a repo transfer + /// + /// - `owner`: owner of the repo to transfer + /// - `repo`: name of the repo to transfer + pub async fn reject_repo_transfer( + &self, + owner: &str, + repo: &str, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/transfer/reject")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a wiki page + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `body` + pub async fn repo_create_wiki_page( + &self, + owner: &str, + repo: &str, + body: CreateWikiPageOptions, + ) -> Result { + let request = self + .post(&format!("/repos/{owner}/{repo}/wiki/new")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a wiki page + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `pageName`: name of the page + pub async fn repo_get_wiki_page( + &self, + owner: &str, + repo: &str, + page_name: &str, + ) -> Result { + let request = self + .get(&format!("/repos/{owner}/{repo}/wiki/page/{page_name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a wiki page + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `pageName`: name of the page + pub async fn repo_delete_wiki_page( + &self, + owner: &str, + repo: &str, + page_name: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/repos/{owner}/{repo}/wiki/page/{page_name}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a wiki page + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `pageName`: name of the page + /// - `body` + pub async fn repo_edit_wiki_page( + &self, + owner: &str, + repo: &str, + page_name: &str, + body: CreateWikiPageOptions, + ) -> Result { + let request = self + .patch(&format!("/repos/{owner}/{repo}/wiki/page/{page_name}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get all wiki pages + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn repo_get_wiki_pages( + &self, + owner: &str, + repo: &str, + query: RepoGetWikiPagesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/wiki/pages?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get revisions of a wiki page + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + /// - `pageName`: name of the page + pub async fn repo_get_wiki_page_revisions( + &self, + owner: &str, + repo: &str, + page_name: &str, + query: RepoGetWikiPageRevisionsQuery, + ) -> Result { + let request = self + .get(&format!( + "/repos/{owner}/{repo}/wiki/revisions/{page_name}?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a repository using a template + /// + /// - `template_owner`: name of the template repository owner + /// - `template_repo`: name of the template repository + /// - `body` + pub async fn generate_repo( + &self, + template_owner: &str, + template_repo: &str, + body: GenerateRepoOption, + ) -> Result { + let request = self + .post(&format!("/repos/{template_owner}/{template_repo}/generate")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a repository by id + /// + /// - `id`: id of the repo to get + pub async fn repo_get_by_id(&self, id: u64) -> Result { + let request = self.get(&format!("/repositories/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get instance's global settings for api + pub async fn get_general_api_settings(&self) -> Result { + let request = self.get("/settings/api").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get instance's global settings for Attachment + pub async fn get_general_attachment_settings( + &self, + ) -> Result { + let request = self.get("/settings/attachment").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get instance's global settings for repositories + pub async fn get_general_repository_settings( + &self, + ) -> Result { + let request = self.get("/settings/repository").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get instance's global settings for ui + pub async fn get_general_ui_settings(&self) -> Result { + let request = self.get("/settings/ui").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get default signing-key.gpg + pub async fn get_signing_key(&self) -> Result { + let request = self.get("/signing-key.gpg").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a team + /// + /// - `id`: id of the team to get + pub async fn org_get_team(&self, id: u64) -> Result { + let request = self.get(&format!("/teams/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a team + /// + /// - `id`: id of the team to delete + pub async fn org_delete_team(&self, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/teams/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Edit a team + /// + /// - `id`: id of the team to edit + /// - `body` + pub async fn org_edit_team(&self, id: u32, body: EditTeamOption) -> Result { + let request = self.patch(&format!("/teams/{id}")).json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a team's activity feeds + /// + /// - `id`: id of the team + pub async fn org_list_team_activity_feeds( + &self, + id: u64, + query: OrgListTeamActivityFeedsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/teams/{id}/activities/feeds?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a team's members + /// + /// - `id`: id of the team + pub async fn org_list_team_members( + &self, + id: u64, + query: OrgListTeamMembersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/teams/{id}/members?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a particular member of team + /// + /// - `id`: id of the team + /// - `username`: username of the member to list + pub async fn org_list_team_member( + &self, + id: u64, + username: &str, + ) -> Result { + let request = self + .get(&format!("/teams/{id}/members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a team member + /// + /// - `id`: id of the team + /// - `username`: username of the user to add + pub async fn org_add_team_member(&self, id: u64, username: &str) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/teams/{id}/members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a team member + /// + /// - `id`: id of the team + /// - `username`: username of the user to remove + pub async fn org_remove_team_member( + &self, + id: u64, + username: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/teams/{id}/members/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a team's repos + /// + /// - `id`: id of the team + pub async fn org_list_team_repos( + &self, + id: u64, + query: OrgListTeamReposQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/teams/{id}/repos?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a particular repo of team + /// + /// - `id`: id of the team + /// - `org`: organization that owns the repo to list + /// - `repo`: name of the repo to list + pub async fn org_list_team_repo( + &self, + id: u64, + org: &str, + repo: &str, + ) -> Result { + let request = self + .get(&format!("/teams/{id}/repos/{org}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add a repository to a team + /// + /// - `id`: id of the team + /// - `org`: organization that owns the repo to add + /// - `repo`: name of the repo to add + pub async fn org_add_team_repository( + &self, + id: u64, + org: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/teams/{id}/repos/{org}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a repository from a team + /// + /// - `id`: id of the team + /// - `org`: organization that owns the repo to remove + /// - `repo`: name of the repo to remove + pub async fn org_remove_team_repository( + &self, + id: u64, + org: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/teams/{id}/repos/{org}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// search topics via keyword + /// + pub async fn topic_search( + &self, + query: TopicSearchQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/topics/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get the authenticated user + pub async fn user_get_current(&self) -> Result { + let request = self.get("/user").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create or Update a secret value in a user scope + /// + /// - `secretname`: name of the secret + /// - `body` + pub async fn update_user_secret( + &self, + secretname: &str, + body: CreateOrUpdateSecretOption, + ) -> Result<(), ForgejoError> { + let request = self + .put(&format!("/user/actions/secrets/{secretname}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(()), + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a secret in a user scope + /// + /// - `secretname`: name of the secret + pub async fn delete_user_secret(&self, secretname: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/user/actions/secrets/{secretname}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's oauth2 applications + /// + pub async fn user_get_oauth2_applications( + &self, + query: UserGetOAuth2ApplicationsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/applications/oauth2?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// creates a new OAuth2 application + /// + /// - `body` + pub async fn user_create_oauth2_application( + &self, + body: CreateOAuth2ApplicationOptions, + ) -> Result { + let request = self.post("/user/applications/oauth2").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// get an OAuth2 Application + /// + /// - `id`: Application ID to be found + pub async fn user_get_oauth2_application( + &self, + id: u64, + ) -> Result { + let request = self + .get(&format!("/user/applications/oauth2/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// delete an OAuth2 Application + /// + /// - `id`: token to be deleted + pub async fn user_delete_oauth2_application(&self, id: u64) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/user/applications/oauth2/{id}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// update an OAuth2 Application, this includes regenerating the client secret + /// + /// - `id`: application to be updated + /// - `body` + pub async fn user_update_oauth2_application( + &self, + id: u64, + body: CreateOAuth2ApplicationOptions, + ) -> Result { + let request = self + .patch(&format!("/user/applications/oauth2/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update Avatar + /// + /// - `body` + pub async fn user_update_avatar( + &self, + body: UpdateUserAvatarOption, + ) -> Result<(), ForgejoError> { + let request = self.post("/user/avatar").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete Avatar + pub async fn user_delete_avatar(&self) -> Result<(), ForgejoError> { + let request = self.delete("/user/avatar").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Blocks a user from the doer. + /// + /// - `username`: username of the user + pub async fn user_block_user(&self, username: &str) -> Result<(), ForgejoError> { + let request = self.put(&format!("/user/block/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's email addresses + pub async fn user_list_emails(&self) -> Result, ForgejoError> { + let request = self.get("/user/emails").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Add email addresses + /// + /// - `body` + pub async fn user_add_email( + &self, + body: CreateEmailOption, + ) -> Result, ForgejoError> { + let request = self.post("/user/emails").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete email addresses + /// + /// - `body` + pub async fn user_delete_email(&self, body: DeleteEmailOption) -> Result<(), ForgejoError> { + let request = self.delete("/user/emails").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's followers + /// + pub async fn user_current_list_followers( + &self, + query: UserCurrentListFollowersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/followers?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the users that the authenticated user is following + /// + pub async fn user_current_list_following( + &self, + query: UserCurrentListFollowingQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/following?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check whether a user is followed by the authenticated user + /// + /// - `username`: username of followed user + pub async fn user_current_check_following(&self, username: &str) -> Result<(), ForgejoError> { + let request = self.get(&format!("/user/following/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Follow a user + /// + /// - `username`: username of user to follow + pub async fn user_current_put_follow(&self, username: &str) -> Result<(), ForgejoError> { + let request = self.put(&format!("/user/following/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unfollow a user + /// + /// - `username`: username of user to unfollow + pub async fn user_current_delete_follow(&self, username: &str) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/user/following/{username}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a Token to verify + pub async fn get_verification_token(&self) -> Result { + let request = self.get("/user/gpg_key_token").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.text().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Verify a GPG key + pub async fn user_verify_gpg_key(&self) -> Result { + let request = self.post("/user/gpg_key_verify").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's GPG keys + /// + pub async fn user_current_list_gpg_keys( + &self, + query: UserCurrentListGpgKeysQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/gpg_keys?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a GPG key + /// + /// - `Form` + pub async fn user_current_post_gpg_key( + &self, + form: CreateGPGKeyOption, + ) -> Result { + let request = self.post("/user/gpg_keys").json(&form).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a GPG key + /// + /// - `id`: id of key to get + pub async fn user_current_get_gpg_key(&self, id: u64) -> Result { + let request = self.get(&format!("/user/gpg_keys/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Remove a GPG key + /// + /// - `id`: id of key to delete + pub async fn user_current_delete_gpg_key(&self, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/user/gpg_keys/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's webhooks + /// + pub async fn user_list_hooks( + &self, + query: UserListHooksQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/hooks?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a hook + /// + /// - `body` + pub async fn user_create_hook(&self, body: CreateHookOption) -> Result { + let request = self.post("/user/hooks").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a hook + /// + /// - `id`: id of the hook to get + pub async fn user_get_hook(&self, id: u64) -> Result { + let request = self.get(&format!("/user/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a hook + /// + /// - `id`: id of the hook to delete + pub async fn user_delete_hook(&self, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/user/hooks/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update a hook + /// + /// - `id`: id of the hook to update + /// - `body` + pub async fn user_edit_hook( + &self, + id: u64, + body: EditHookOption, + ) -> Result { + let request = self + .patch(&format!("/user/hooks/{id}")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's public keys + /// + pub async fn user_current_list_keys( + &self, + query: UserCurrentListKeysQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/keys?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a public key + /// + /// - `body` + pub async fn user_current_post_key( + &self, + body: CreateKeyOption, + ) -> Result { + let request = self.post("/user/keys").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a public key + /// + /// - `id`: id of key to get + pub async fn user_current_get_key(&self, id: u64) -> Result { + let request = self.get(&format!("/user/keys/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Delete a public key + /// + /// - `id`: id of key to delete + pub async fn user_current_delete_key(&self, id: u64) -> Result<(), ForgejoError> { + let request = self.delete(&format!("/user/keys/{id}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's blocked users + /// + pub async fn user_list_blocked_users( + &self, + query: UserListBlockedUsersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/list_blocked?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the current user's organizations + /// + pub async fn org_list_current_user_orgs( + &self, + query: OrgListCurrentUserOrgsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/orgs?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the repos that the authenticated user owns + /// + pub async fn user_current_list_repos( + &self, + query: UserCurrentListReposQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/repos?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create a repository + /// + /// - `body` + pub async fn create_current_user_repo( + &self, + body: CreateRepoOption, + ) -> Result { + let request = self.post("/user/repos").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get user settings + pub async fn get_user_settings(&self) -> Result, ForgejoError> { + let request = self.get("/user/settings").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Update user settings + /// + /// - `body` + pub async fn update_user_settings( + &self, + body: UserSettingsOptions, + ) -> Result, ForgejoError> { + let request = self.patch("/user/settings").json(&body).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// The repos that the authenticated user has starred + /// + pub async fn user_current_list_starred( + &self, + query: UserCurrentListStarredQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/starred?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Whether the authenticated is starring the repo + /// + /// - `owner`: owner of the repo + /// - `repo`: name of the repo + pub async fn user_current_check_starring( + &self, + owner: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self.get(&format!("/user/starred/{owner}/{repo}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Star the given repo + /// + /// - `owner`: owner of the repo to star + /// - `repo`: name of the repo to star + pub async fn user_current_put_star(&self, owner: &str, repo: &str) -> Result<(), ForgejoError> { + let request = self.put(&format!("/user/starred/{owner}/{repo}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unstar the given repo + /// + /// - `owner`: owner of the repo to unstar + /// - `repo`: name of the repo to unstar + pub async fn user_current_delete_star( + &self, + owner: &str, + repo: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/user/starred/{owner}/{repo}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get list of all existing stopwatches + /// + pub async fn user_get_stop_watches( + &self, + query: UserGetStopWatchesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/stopwatches?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List repositories watched by the authenticated user + /// + pub async fn user_current_list_subscriptions( + &self, + query: UserCurrentListSubscriptionsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/subscriptions?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List all the teams a user belongs to + /// + pub async fn user_list_teams( + &self, + query: UserListTeamsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/teams?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the current user's tracked times + /// + pub async fn user_current_tracked_times( + &self, + query: UserCurrentTrackedTimesQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/user/times?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Unblocks a user from the doer. + /// + /// - `username`: username of the user + pub async fn user_unblock_user(&self, username: &str) -> Result<(), ForgejoError> { + let request = self.put(&format!("/user/unblock/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Search for users + /// + pub async fn user_search( + &self, + query: UserSearchQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/search?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a user + /// + /// - `username`: username of user to get + pub async fn user_get(&self, username: &str) -> Result { + let request = self.get(&format!("/users/{username}")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a user's activity feeds + /// + /// - `username`: username of user + pub async fn user_list_activity_feeds( + &self, + username: &str, + query: UserListActivityFeedsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/users/{username}/activities/feeds?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the given user's followers + /// + /// - `username`: username of user + pub async fn user_list_followers( + &self, + username: &str, + query: UserListFollowersQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/users/{username}/followers?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the users that the given user is following + /// + /// - `username`: username of user + pub async fn user_list_following( + &self, + username: &str, + query: UserListFollowingQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/users/{username}/following?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Check if one user is following another user + /// + /// - `username`: username of following user + /// - `target`: username of followed user + pub async fn user_check_following( + &self, + username: &str, + target: &str, + ) -> Result<(), ForgejoError> { + let request = self + .get(&format!("/users/{username}/following/{target}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the given user's GPG keys + /// + /// - `username`: username of user + pub async fn user_list_gpg_keys( + &self, + username: &str, + query: UserListGpgKeysQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/gpg_keys?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get a user's heatmap + /// + /// - `username`: username of user to get + pub async fn user_get_heatmap_data( + &self, + username: &str, + ) -> Result, ForgejoError> { + let request = self.get(&format!("/users/{username}/heatmap")).build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the given user's public keys + /// + /// - `username`: username of user + pub async fn user_list_keys( + &self, + username: &str, + query: UserListKeysQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/keys?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List a user's organizations + /// + /// - `username`: username of user + pub async fn org_list_user_orgs( + &self, + username: &str, + query: OrgListUserOrgsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/orgs?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Get user permissions in organization + /// + /// - `username`: username of user + /// - `org`: name of the organization + pub async fn org_get_user_permissions( + &self, + username: &str, + org: &str, + ) -> Result { + let request = self + .get(&format!("/users/{username}/orgs/{org}/permissions")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the repos owned by the given user + /// + /// - `username`: username of user + pub async fn user_list_repos( + &self, + username: &str, + query: UserListReposQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/repos?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// The repos that the given user has starred + /// + /// - `username`: username of user + pub async fn user_list_starred( + &self, + username: &str, + query: UserListStarredQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/starred?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the repositories watched by a user + /// + /// - `username`: username of the user + pub async fn user_list_subscriptions( + &self, + username: &str, + query: UserListSubscriptionsQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!( + "/users/{username}/subscriptions?{}", + query.to_string() + )) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// List the authenticated user's access tokens + /// + /// - `username`: username of user + pub async fn user_get_tokens( + &self, + username: &str, + query: UserGetTokensQuery, + ) -> Result, ForgejoError> { + let request = self + .get(&format!("/users/{username}/tokens?{}", query.to_string())) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Create an access token + /// + /// - `username`: username of user + /// - `body` + pub async fn user_create_token( + &self, + username: &str, + body: CreateAccessTokenOption, + ) -> Result { + let request = self + .post(&format!("/users/{username}/tokens")) + .json(&body) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 201 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// delete an access token + /// + /// - `username`: username of user + /// - `token`: token to be deleted, identified by ID and if not available by name + pub async fn user_delete_access_token( + &self, + username: &str, + token: &str, + ) -> Result<(), ForgejoError> { + let request = self + .delete(&format!("/users/{username}/tokens/{token}")) + .build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 204 => Ok(()), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } + + /// Returns the version of the Gitea application + pub async fn get_version(&self) -> Result { + let request = self.get("/version").build()?; + let response = self.execute(request).await?; + match response.status().as_u16() { + 200 => Ok(response.json().await?), + _ => Err(ForgejoError::UnexpectedStatusCode(response.status())), + } + } +} +use structs::*; +pub mod structs { + use std::fmt::Write; + /// APIError is an api error with a message + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct APIError { + pub message: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct AccessToken { + pub id: Option, + pub name: Option, + pub scopes: Option>, + pub sha1: Option, + pub token_last_eight: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Activity { + pub act_user: Option, + pub act_user_id: Option, + pub comment: Option, + pub comment_id: Option, + pub content: Option, + pub created: Option, + pub id: Option, + pub is_private: Option, + pub op_type: Option, + pub ref_name: Option, + pub repo: Option, + pub repo_id: Option, + pub user_id: Option, + } + + /// ActivityPub type + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ActivityPub { + #[serde(rename = "@context")] + pub context: Option, + } + + /// AddCollaboratorOption options when adding a user as a collaborator of a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct AddCollaboratorOption { + pub permission: Option, + } + + /// AddTimeOption options for adding time to an issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct AddTimeOption { + pub created: Option, + pub time: u64, + pub user_name: Option, + } + + /// AnnotatedTag represents an annotated tag + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct AnnotatedTag { + pub message: Option, + pub object: Option, + pub sha: Option, + pub tag: Option, + pub tagger: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub verification: Option, + } + + /// AnnotatedTagObject contains meta information of the tag object + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct AnnotatedTagObject { + pub sha: Option, + #[serde(rename = "type")] + pub r#type: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// Attachment a generic attachment + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Attachment { + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub browser_download_url: Option, + pub created_at: Option, + pub download_count: Option, + pub id: Option, + pub name: Option, + pub size: Option, + pub uuid: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct BlockedUser { + pub block_id: Option, + pub created_at: Option, + } + + /// Branch represents a repository branch + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Branch { + pub commit: Option, + pub effective_branch_protection_name: Option, + pub enable_status_check: Option, + pub name: Option, + pub protected: Option, + pub required_approvals: Option, + pub status_check_contexts: Option>, + pub user_can_merge: Option, + pub user_can_push: Option, + } + + /// BranchProtection represents a branch protection for a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct BranchProtection { + pub approvals_whitelist_teams: Option>, + pub approvals_whitelist_username: Option>, + pub block_on_official_review_requests: Option, + pub block_on_outdated_branch: Option, + pub block_on_rejected_reviews: Option, + pub branch_name: Option, + pub created_at: Option, + pub dismiss_stale_approvals: Option, + pub enable_approvals_whitelist: Option, + pub enable_merge_whitelist: Option, + pub enable_push: Option, + pub enable_push_whitelist: Option, + pub enable_status_check: Option, + pub merge_whitelist_teams: Option>, + pub merge_whitelist_usernames: Option>, + pub protected_file_patterns: Option, + pub push_whitelist_deploy_keys: Option, + pub push_whitelist_teams: Option>, + pub push_whitelist_usernames: Option>, + pub require_signed_commits: Option, + pub required_approvals: Option, + pub rule_name: Option, + pub status_check_contexts: Option>, + pub unprotected_file_patterns: Option, + pub updated_at: Option, + } + + /// ChangeFileOperation for creating, updating or deleting a file + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ChangeFileOperation { + pub content: Option, + pub from_path: Option, + pub operation: String, + pub path: String, + pub sha: Option, + } + + /// ChangeFilesOptions options for creating, updating or deleting multiple files + /// + /// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used) + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ChangeFilesOptions { + pub author: Option, + pub branch: Option, + pub committer: Option, + pub dates: Option, + pub files: Vec, + pub message: Option, + pub new_branch: Option, + pub signoff: Option, + } + + /// ChangedFile store information about files affected by the pull request + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ChangedFile { + pub additions: Option, + pub changes: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub contents_url: Option, + pub deletions: Option, + pub filename: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub previous_filename: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub raw_url: Option, + pub status: Option, + } + + /// CombinedStatus holds the combined state of several statuses for a single commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CombinedStatus { + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub commit_url: Option, + pub repository: Option, + pub sha: Option, + pub state: Option, + pub statuses: Option>, + pub total_count: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// Comment represents a comment on a commit or issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Comment { + pub assets: Option>, + pub body: Option, + pub created_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub issue_url: Option, + pub original_author: Option, + pub original_author_id: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub pull_request_url: Option, + pub updated_at: Option, + pub user: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Commit { + pub author: Option, + pub commit: Option, + pub committer: Option, + pub created: Option, + pub files: Option>, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub parents: Option>, + pub sha: Option, + pub stats: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// CommitAffectedFiles store information about files affected by the commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitAffectedFiles { + pub filename: Option, + pub status: Option, + } + + /// CommitDateOptions store dates for GIT_AUTHOR_DATE and GIT_COMMITTER_DATE + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitDateOptions { + pub author: Option, + pub committer: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitMeta { + pub created: Option, + pub sha: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// CommitStats is statistics for a RepoCommit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitStats { + pub additions: Option, + pub deletions: Option, + pub total: Option, + } + + /// CommitStatus holds a single status of a single Commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitStatus { + pub context: Option, + pub created_at: Option, + pub creator: Option, + pub description: Option, + pub id: Option, + pub status: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub target_url: Option, + pub updated_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// CommitStatusState holds the state of a CommitStatus + /// + /// It can be "pending", "success", "error" and "failure" + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitStatusState {} + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CommitUser { + pub date: Option, + pub email: Option, + pub name: Option, + } + + /// ContentsResponse contains information about a repo's entry's (dir, file, symlink, submodule) metadata and content + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ContentsResponse { + #[serde(rename = "_links")] + pub links: Option, + pub content: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub download_url: Option, + pub encoding: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub git_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub last_commit_sha: Option, + pub name: Option, + pub path: Option, + pub sha: Option, + pub size: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub submodule_git_url: Option, + pub target: Option, + #[serde(rename = "type")] + pub r#type: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// CreateAccessTokenOption options when create access token + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateAccessTokenOption { + pub name: String, + pub scopes: Option>, + } + + /// CreateBranchProtectionOption options for creating a branch protection + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateBranchProtectionOption { + pub approvals_whitelist_teams: Option>, + pub approvals_whitelist_username: Option>, + pub block_on_official_review_requests: Option, + pub block_on_outdated_branch: Option, + pub block_on_rejected_reviews: Option, + pub branch_name: Option, + pub dismiss_stale_approvals: Option, + pub enable_approvals_whitelist: Option, + pub enable_merge_whitelist: Option, + pub enable_push: Option, + pub enable_push_whitelist: Option, + pub enable_status_check: Option, + pub merge_whitelist_teams: Option>, + pub merge_whitelist_usernames: Option>, + pub protected_file_patterns: Option, + pub push_whitelist_deploy_keys: Option, + pub push_whitelist_teams: Option>, + pub push_whitelist_usernames: Option>, + pub require_signed_commits: Option, + pub required_approvals: Option, + pub rule_name: Option, + pub status_check_contexts: Option>, + pub unprotected_file_patterns: Option, + } + + /// CreateBranchRepoOption options when creating a branch in a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateBranchRepoOption { + pub new_branch_name: String, + pub old_branch_name: Option, + pub old_ref_name: Option, + } + + /// CreateEmailOption options when creating email addresses + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateEmailOption { + pub emails: Option>, + } + + /// CreateFileOptions options for creating files + /// + /// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used) + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateFileOptions { + pub author: Option, + pub branch: Option, + pub committer: Option, + pub content: String, + pub dates: Option, + pub message: Option, + pub new_branch: Option, + pub signoff: Option, + } + + /// CreateForkOption options for creating a fork + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateForkOption { + pub name: Option, + pub organization: Option, + } + + /// CreateGPGKeyOption options create user GPG key + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateGPGKeyOption { + pub armored_public_key: String, + pub armored_signature: Option, + } + + /// CreateHookOption options when create a hook + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateHookOption { + pub active: Option, + pub authorization_header: Option, + pub branch_filter: Option, + pub config: CreateHookOptionConfig, + pub events: Option>, + #[serde(rename = "type")] + pub r#type: String, + } + + /// CreateHookOptionConfig has all config options in it + /// + /// required are "content_type" and "url" Required + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateHookOptionConfig {} + + /// CreateIssueCommentOption options for creating a comment on an issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateIssueCommentOption { + pub body: String, + pub updated_at: Option, + } + + /// CreateIssueOption options to create one issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateIssueOption { + pub assignee: Option, + pub assignees: Option>, + pub body: Option, + pub closed: Option, + pub due_date: Option, + pub labels: Option>, + pub milestone: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + pub title: String, + } + + /// CreateKeyOption options when creating a key + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateKeyOption { + pub key: String, + pub read_only: Option, + pub title: String, + } + + /// CreateLabelOption options for creating a label + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateLabelOption { + pub color: String, + pub description: Option, + pub exclusive: Option, + pub is_archived: Option, + pub name: String, + } + + /// CreateMilestoneOption options for creating a milestone + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateMilestoneOption { + pub description: Option, + pub due_on: Option, + pub state: Option, + pub title: Option, + } + + /// CreateOAuth2ApplicationOptions holds options to create an oauth2 application + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateOAuth2ApplicationOptions { + pub confidential_client: Option, + pub name: Option, + pub redirect_uris: Option>, + } + + /// CreateOrUpdateSecretOption options when creating or updating secret + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateOrUpdateSecretOption { + pub data: String, + } + + /// CreateOrgOption options for creating an organization + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateOrgOption { + pub description: Option, + pub email: Option, + pub full_name: Option, + pub location: Option, + pub repo_admin_change_team_access: Option, + pub username: String, + pub visibility: Option, + pub website: Option, + } + + /// CreatePullRequestOption options when creating a pull request + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreatePullRequestOption { + pub assignee: Option, + pub assignees: Option>, + pub base: Option, + pub body: Option, + pub due_date: Option, + pub head: Option, + pub labels: Option>, + pub milestone: Option, + pub title: Option, + } + + /// CreatePullReviewComment represent a review comment for creation api + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreatePullReviewComment { + pub body: Option, + pub new_position: Option, + pub old_position: Option, + pub path: Option, + } + + /// CreatePullReviewOptions are options to create a pull review + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreatePullReviewOptions { + pub body: Option, + pub comments: Option>, + pub commit_id: Option, + pub event: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreatePushMirrorOption { + pub interval: Option, + pub remote_address: Option, + pub remote_password: Option, + pub remote_username: Option, + pub sync_on_commit: Option, + } + + /// CreateReleaseOption options when creating a release + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateReleaseOption { + pub body: Option, + pub draft: Option, + pub name: Option, + pub prerelease: Option, + pub tag_name: String, + pub target_commitish: Option, + } + + /// CreateRepoOption options when creating repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateRepoOption { + pub auto_init: Option, + pub default_branch: Option, + pub description: Option, + pub gitignores: Option, + pub issue_labels: Option, + pub license: Option, + pub name: String, + pub private: Option, + pub readme: Option, + pub template: Option, + pub trust_model: Option, + } + + /// CreateStatusOption holds the information needed to create a new CommitStatus for a Commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateStatusOption { + pub context: Option, + pub description: Option, + pub state: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub target_url: Option, + } + + /// CreateTagOption options when creating a tag + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateTagOption { + pub message: Option, + pub tag_name: String, + pub target: Option, + } + + /// CreateTeamOption options for creating a team + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateTeamOption { + pub can_create_org_repo: Option, + pub description: Option, + pub includes_all_repositories: Option, + pub name: String, + pub permission: Option, + pub units: Option>, + pub units_map: Option>, + } + + /// CreateUserOption create user options + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateUserOption { + pub created_at: Option, + pub email: String, + pub full_name: Option, + pub login_name: Option, + pub must_change_password: Option, + pub password: Option, + pub restricted: Option, + pub send_notify: Option, + pub source_id: Option, + pub username: String, + pub visibility: Option, + } + + /// CreateWikiPageOptions form for creating wiki + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct CreateWikiPageOptions { + pub content_base64: Option, + pub message: Option, + pub title: Option, + } + + /// Cron represents a Cron task + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Cron { + pub exec_times: Option, + pub name: Option, + pub next: Option, + pub prev: Option, + pub schedule: Option, + } + + /// DeleteEmailOption options when deleting email addresses + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct DeleteEmailOption { + pub emails: Option>, + } + + /// DeleteFileOptions options for deleting files (used for other File structs below) + /// + /// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used) + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct DeleteFileOptions { + pub author: Option, + pub branch: Option, + pub committer: Option, + pub dates: Option, + pub message: Option, + pub new_branch: Option, + pub sha: String, + pub signoff: Option, + } + + /// DeleteLabelOption options for deleting a label + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct DeleteLabelsOption { + pub updated_at: Option, + } + + /// DeployKey a deploy key + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct DeployKey { + pub created_at: Option, + pub fingerprint: Option, + pub id: Option, + pub key: Option, + pub key_id: Option, + pub read_only: Option, + pub repository: Option, + pub title: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// DismissPullReviewOptions are options to dismiss a pull review + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct DismissPullReviewOptions { + pub message: Option, + pub priors: Option, + } + + /// EditAttachmentOptions options for editing attachments + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditAttachmentOptions { + pub name: Option, + } + + /// EditBranchProtectionOption options for editing a branch protection + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditBranchProtectionOption { + pub approvals_whitelist_teams: Option>, + pub approvals_whitelist_username: Option>, + pub block_on_official_review_requests: Option, + pub block_on_outdated_branch: Option, + pub block_on_rejected_reviews: Option, + pub dismiss_stale_approvals: Option, + pub enable_approvals_whitelist: Option, + pub enable_merge_whitelist: Option, + pub enable_push: Option, + pub enable_push_whitelist: Option, + pub enable_status_check: Option, + pub merge_whitelist_teams: Option>, + pub merge_whitelist_usernames: Option>, + pub protected_file_patterns: Option, + pub push_whitelist_deploy_keys: Option, + pub push_whitelist_teams: Option>, + pub push_whitelist_usernames: Option>, + pub require_signed_commits: Option, + pub required_approvals: Option, + pub status_check_contexts: Option>, + pub unprotected_file_patterns: Option, + } + + /// EditDeadlineOption options for creating a deadline + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditDeadlineOption { + pub due_date: time::OffsetDateTime, + } + + /// EditGitHookOption options when modifying one Git hook + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditGitHookOption { + pub content: Option, + } + + /// EditHookOption options when modify one hook + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditHookOption { + pub active: Option, + pub authorization_header: Option, + pub branch_filter: Option, + pub config: Option>, + pub events: Option>, + } + + /// EditIssueCommentOption options for editing a comment + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditIssueCommentOption { + pub body: String, + pub updated_at: Option, + } + + /// EditIssueOption options for editing an issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditIssueOption { + pub assignee: Option, + pub assignees: Option>, + pub body: Option, + pub due_date: Option, + pub milestone: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + pub state: Option, + pub title: Option, + pub unset_due_date: Option, + pub updated_at: Option, + } + + /// EditLabelOption options for editing a label + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditLabelOption { + pub color: Option, + pub description: Option, + pub exclusive: Option, + pub is_archived: Option, + pub name: Option, + } + + /// EditMilestoneOption options for editing a milestone + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditMilestoneOption { + pub description: Option, + pub due_on: Option, + pub state: Option, + pub title: Option, + } + + /// EditOrgOption options for editing an organization + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditOrgOption { + pub description: Option, + pub email: Option, + pub full_name: Option, + pub location: Option, + pub repo_admin_change_team_access: Option, + pub visibility: Option, + pub website: Option, + } + + /// EditPullRequestOption options when modify pull request + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditPullRequestOption { + pub allow_maintainer_edit: Option, + pub assignee: Option, + pub assignees: Option>, + pub base: Option, + pub body: Option, + pub due_date: Option, + pub labels: Option>, + pub milestone: Option, + pub state: Option, + pub title: Option, + pub unset_due_date: Option, + } + + /// EditReactionOption contain the reaction type + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditReactionOption { + pub content: Option, + } + + /// EditReleaseOption options when editing a release + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditReleaseOption { + pub body: Option, + pub draft: Option, + pub name: Option, + pub prerelease: Option, + pub tag_name: Option, + pub target_commitish: Option, + } + + /// EditRepoOption options when editing a repository's properties + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditRepoOption { + pub allow_manual_merge: Option, + pub allow_merge_commits: Option, + pub allow_rebase: Option, + pub allow_rebase_explicit: Option, + pub allow_rebase_update: Option, + pub allow_squash_merge: Option, + pub archived: Option, + pub autodetect_manual_merge: Option, + pub default_allow_maintainer_edit: Option, + pub default_branch: Option, + pub default_delete_branch_after_merge: Option, + pub default_merge_style: Option, + pub description: Option, + pub enable_prune: Option, + pub external_tracker: Option, + pub external_wiki: Option, + pub has_actions: Option, + pub has_issues: Option, + pub has_packages: Option, + pub has_projects: Option, + pub has_pull_requests: Option, + pub has_releases: Option, + pub has_wiki: Option, + pub ignore_whitespace_conflicts: Option, + pub internal_tracker: Option, + pub mirror_interval: Option, + pub name: Option, + pub private: Option, + pub template: Option, + pub website: Option, + } + + /// EditTeamOption options for editing a team + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditTeamOption { + pub can_create_org_repo: Option, + pub description: Option, + pub includes_all_repositories: Option, + pub name: String, + pub permission: Option, + pub units: Option>, + pub units_map: Option>, + } + + /// EditUserOption edit user options + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct EditUserOption { + pub active: Option, + pub admin: Option, + pub allow_create_organization: Option, + pub allow_git_hook: Option, + pub allow_import_local: Option, + pub description: Option, + pub email: Option, + pub full_name: Option, + pub location: Option, + pub login_name: String, + pub max_repo_creation: Option, + pub must_change_password: Option, + pub password: Option, + pub prohibit_login: Option, + pub restricted: Option, + pub source_id: u64, + pub visibility: Option, + pub website: Option, + } + + /// Email an email address belonging to a user + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Email { + pub email: Option, + pub primary: Option, + pub user_id: Option, + pub username: Option, + pub verified: Option, + } + + /// ExternalTracker represents settings for external tracker + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ExternalTracker { + pub external_tracker_format: Option, + pub external_tracker_regexp_pattern: Option, + pub external_tracker_style: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub external_tracker_url: Option, + } + + /// ExternalWiki represents setting for external wiki + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ExternalWiki { + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub external_wiki_url: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct FileCommitResponse { + pub author: Option, + pub committer: Option, + pub created: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub message: Option, + pub parents: Option>, + pub sha: Option, + pub tree: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// FileDeleteResponse contains information about a repo's file that was deleted + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct FileDeleteResponse { + pub commit: Option, + pub content: Option<()>, + pub verification: Option, + } + + /// FileLinksResponse contains the links for a repo's file + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct FileLinksResponse { + pub git: Option, + pub html: Option, + #[serde(rename = "self")] + pub this: Option, + } + + /// FileResponse contains information about a repo's file + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct FileResponse { + pub commit: Option, + pub content: Option, + pub verification: Option, + } + + /// FilesResponse contains information about multiple files from a repo + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct FilesResponse { + pub commit: Option, + pub files: Option>, + pub verification: Option, + } + + /// GPGKey a user GPG key to sign commit and tag in repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GPGKey { + pub can_certify: Option, + pub can_encrypt_comms: Option, + pub can_encrypt_storage: Option, + pub can_sign: Option, + pub created_at: Option, + pub emails: Option>, + pub expires_at: Option, + pub id: Option, + pub key_id: Option, + pub primary_key_id: Option, + pub public_key: Option, + pub subkeys: Option>, + pub verified: Option, + } + + /// GPGKeyEmail an email attached to a GPGKey + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GPGKeyEmail { + pub email: Option, + pub verified: Option, + } + + /// GeneralAPISettings contains global api settings exposed by it + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GeneralAPISettings { + pub default_git_trees_per_page: Option, + pub default_max_blob_size: Option, + pub default_paging_num: Option, + pub max_response_items: Option, + } + + /// GeneralAttachmentSettings contains global Attachment settings exposed by API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GeneralAttachmentSettings { + pub allowed_types: Option, + pub enabled: Option, + pub max_files: Option, + pub max_size: Option, + } + + /// GeneralRepoSettings contains global repository settings exposed by API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GeneralRepoSettings { + pub http_git_disabled: Option, + pub lfs_disabled: Option, + pub migrations_disabled: Option, + pub mirrors_disabled: Option, + pub stars_disabled: Option, + pub time_tracking_disabled: Option, + } + + /// GeneralUISettings contains global ui settings exposed by API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GeneralUISettings { + pub allowed_reactions: Option>, + pub custom_emojis: Option>, + pub default_theme: Option, + } + + /// GenerateRepoOption options when creating repository using a template + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GenerateRepoOption { + pub avatar: Option, + pub default_branch: Option, + pub description: Option, + pub git_content: Option, + pub git_hooks: Option, + pub labels: Option, + pub name: String, + pub owner: String, + pub private: Option, + pub protected_branch: Option, + pub topics: Option, + pub webhooks: Option, + } + + /// GitBlobResponse represents a git blob + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitBlobResponse { + pub content: Option, + pub encoding: Option, + pub sha: Option, + pub size: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// GitEntry represents a git tree + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitEntry { + pub mode: Option, + pub path: Option, + pub sha: Option, + pub size: Option, + #[serde(rename = "type")] + pub r#type: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// GitHook represents a Git repository hook + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitHook { + pub content: Option, + pub is_active: Option, + pub name: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitObject { + pub sha: Option, + #[serde(rename = "type")] + pub r#type: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// GitTreeResponse returns a git tree + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitTreeResponse { + pub page: Option, + pub sha: Option, + pub total_count: Option, + pub tree: Option>, + pub truncated: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// GitignoreTemplateInfo name and text of a gitignore template + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct GitignoreTemplateInfo { + pub name: Option, + pub source: Option, + } + + /// Hook a hook is a web hook when one repository changed + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Hook { + pub active: Option, + pub authorization_header: Option, + pub branch_filter: Option, + pub config: Option>, + pub created_at: Option, + pub events: Option>, + pub id: Option, + #[serde(rename = "type")] + pub r#type: Option, + pub updated_at: Option, + } + + /// Identity for a person's identity like an author or committer + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Identity { + pub email: Option, + pub name: Option, + } + + /// InternalTracker represents settings for internal tracker + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct InternalTracker { + pub allow_only_contributors_to_track_time: Option, + pub enable_issue_dependencies: Option, + pub enable_time_tracker: Option, + } + + /// Issue represents an issue in a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Issue { + pub assets: Option>, + pub assignee: Option, + pub assignees: Option>, + pub body: Option, + pub closed_at: Option, + pub comments: Option, + pub created_at: Option, + pub due_date: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub is_locked: Option, + pub labels: Option>, + pub milestone: Option, + pub number: Option, + pub original_author: Option, + pub original_author_id: Option, + pub pin_order: Option, + pub pull_request: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + pub repository: Option, + pub state: Option, + pub title: Option, + pub updated_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub user: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueConfig { + pub blank_issues_enabled: Option, + pub contact_links: Option>, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueConfigContactLink { + pub about: Option, + pub name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueConfigValidation { + pub message: Option, + pub valid: Option, + } + + /// IssueDeadline represents an issue deadline + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueDeadline { + pub due_date: Option, + } + + /// IssueFormField represents a form field + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueFormField { + pub attributes: Option>, + pub id: Option, + #[serde(rename = "type")] + pub r#type: Option, + pub validations: Option>, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueFormFieldType {} + + /// IssueLabelsOption a collection of labels + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueLabelsOption { + pub labels: Option>, + pub updated_at: Option, + } + + /// IssueMeta basic issue information + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueMeta { + pub index: Option, + pub owner: Option, + pub repo: Option, + } + + /// IssueTemplate represents an issue template for a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct IssueTemplate { + pub about: Option, + pub body: Option>, + pub content: Option, + pub file_name: Option, + pub labels: Option>, + pub name: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + pub title: Option, + } + + /// Label a label to an issue or a pr + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Label { + pub color: Option, + pub description: Option, + pub exclusive: Option, + pub id: Option, + pub is_archived: Option, + pub name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// LabelTemplate info of a Label template + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct LabelTemplate { + pub color: Option, + pub description: Option, + pub exclusive: Option, + pub name: Option, + } + + /// LicensesInfo contains information about a License + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct LicenseTemplateInfo { + pub body: Option, + pub implementation: Option, + pub key: Option, + pub name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// LicensesListEntry is used for the API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct LicensesTemplateListEntry { + pub key: Option, + pub name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// MarkdownOption markdown options + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct MarkdownOption { + #[serde(rename = "Context")] + pub context: Option, + #[serde(rename = "Mode")] + pub mode: Option, + #[serde(rename = "Text")] + pub text: Option, + #[serde(rename = "Wiki")] + pub wiki: Option, + } + + /// MarkupOption markup options + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct MarkupOption { + #[serde(rename = "Context")] + pub context: Option, + #[serde(rename = "FilePath")] + pub file_path: Option, + #[serde(rename = "Mode")] + pub mode: Option, + #[serde(rename = "Text")] + pub text: Option, + #[serde(rename = "Wiki")] + pub wiki: Option, + } + + /// MergePullRequestForm form for merging Pull Request + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct MergePullRequestOption { + #[serde(rename = "Do")] + pub r#do: String, + #[serde(rename = "MergeCommitID")] + pub merge_commit_id: Option, + #[serde(rename = "MergeMessageField")] + pub merge_message_field: Option, + #[serde(rename = "MergeTitleField")] + pub merge_title_field: Option, + pub delete_branch_after_merge: Option, + pub force_merge: Option, + pub head_commit_id: Option, + pub merge_when_checks_succeed: Option, + } + + /// MigrateRepoOptions options for migrating repository's + /// + /// this is used to interact with api v1 + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct MigrateRepoOptions { + pub auth_password: Option, + pub auth_token: Option, + pub auth_username: Option, + pub clone_addr: String, + pub description: Option, + pub issues: Option, + pub labels: Option, + pub lfs: Option, + pub lfs_endpoint: Option, + pub milestones: Option, + pub mirror: Option, + pub mirror_interval: Option, + pub private: Option, + pub pull_requests: Option, + pub releases: Option, + pub repo_name: String, + pub repo_owner: Option, + pub service: Option, + pub uid: Option, + pub wiki: Option, + } + + /// Milestone milestone is a collection of issues on one repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Milestone { + pub closed_at: Option, + pub closed_issues: Option, + pub created_at: Option, + pub description: Option, + pub due_on: Option, + pub id: Option, + pub open_issues: Option, + pub state: Option, + pub title: Option, + pub updated_at: Option, + } + + /// NewIssuePinsAllowed represents an API response that says if new Issue Pins are allowed + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NewIssuePinsAllowed { + pub issues: Option, + pub pull_requests: Option, + } + + /// NodeInfo contains standardized way of exposing metadata about a server running one of the distributed social networks + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NodeInfo { + pub metadata: Option>, + #[serde(rename = "openRegistrations")] + pub open_registrations: Option, + pub protocols: Option>, + pub services: Option, + pub software: Option, + pub usage: Option, + pub version: Option, + } + + /// NodeInfoServices contains the third party sites this server can connect to via their application API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NodeInfoServices { + pub inbound: Option>, + pub outbound: Option>, + } + + /// NodeInfoSoftware contains Metadata about server software in use + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NodeInfoSoftware { + pub homepage: Option, + pub name: Option, + pub repository: Option, + pub version: Option, + } + + /// NodeInfoUsage contains usage statistics for this server + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NodeInfoUsage { + #[serde(rename = "localComments")] + pub local_comments: Option, + #[serde(rename = "localPosts")] + pub local_posts: Option, + pub users: Option, + } + + /// NodeInfoUsageUsers contains statistics about the users of this server + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NodeInfoUsageUsers { + #[serde(rename = "activeHalfyear")] + pub active_halfyear: Option, + #[serde(rename = "activeMonth")] + pub active_month: Option, + pub total: Option, + } + + /// Note contains information related to a git note + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Note { + pub commit: Option, + pub message: Option, + } + + /// NotificationCount number of unread notifications + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NotificationCount { + pub new: Option, + } + + /// NotificationSubject contains the notification subject (Issue/Pull/Commit) + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NotificationSubject { + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub latest_comment_html_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub latest_comment_url: Option, + pub state: Option, + pub title: Option, + #[serde(rename = "type")] + pub r#type: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// NotificationThread expose Notification on API + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NotificationThread { + pub id: Option, + pub pinned: Option, + pub repository: Option, + pub subject: Option, + pub unread: Option, + pub updated_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// NotifySubjectType represent type of notification subject + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct NotifySubjectType {} + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct OAuth2Application { + pub client_id: Option, + pub client_secret: Option, + pub confidential_client: Option, + pub created: Option, + pub id: Option, + pub name: Option, + pub redirect_uris: Option>, + } + + /// Organization represents an organization + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Organization { + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub avatar_url: Option, + pub description: Option, + pub email: Option, + pub full_name: Option, + pub id: Option, + pub location: Option, + pub name: Option, + pub repo_admin_change_team_access: Option, + pub username: Option, + pub visibility: Option, + pub website: Option, + } + + /// OrganizationPermissions list different users permissions on an organization + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct OrganizationPermissions { + pub can_create_repository: Option, + pub can_read: Option, + pub can_write: Option, + pub is_admin: Option, + pub is_owner: Option, + } + + /// PRBranchInfo information about a branch + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PRBranchInfo { + pub label: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + pub repo: Option, + pub repo_id: Option, + pub sha: Option, + } + + /// Package represents a package + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Package { + pub created_at: Option, + pub creator: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub name: Option, + pub owner: Option, + pub repository: Option, + #[serde(rename = "type")] + pub r#type: Option, + pub version: Option, + } + + /// PackageFile represents a package file + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PackageFile { + #[serde(rename = "Size")] + pub size: Option, + pub id: Option, + pub md5: Option, + pub name: Option, + pub sha1: Option, + pub sha256: Option, + pub sha512: Option, + } + + /// PayloadCommit represents a commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PayloadCommit { + pub added: Option>, + pub author: Option, + pub committer: Option, + pub id: Option, + pub message: Option, + pub modified: Option>, + pub removed: Option>, + pub timestamp: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub verification: Option, + } + + /// PayloadCommitVerification represents the GPG verification of a commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PayloadCommitVerification { + pub payload: Option, + pub reason: Option, + pub signature: Option, + pub signer: Option, + pub verified: Option, + } + + /// PayloadUser represents the author or committer of a commit + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PayloadUser { + pub email: Option, + pub name: Option, + pub username: Option, + } + + /// Permission represents a set of permissions + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Permission { + pub admin: Option, + pub pull: Option, + pub push: Option, + } + + /// PublicKey publickey is a user key to push code to repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PublicKey { + pub created_at: Option, + pub fingerprint: Option, + pub id: Option, + pub key: Option, + pub key_type: Option, + pub read_only: Option, + pub title: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub user: Option, + } + + /// PullRequest represents a pull request + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PullRequest { + pub allow_maintainer_edit: Option, + pub assignee: Option, + pub assignees: Option>, + pub base: Option, + pub body: Option, + pub closed_at: Option, + pub comments: Option, + pub created_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub diff_url: Option, + pub due_date: Option, + pub head: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub is_locked: Option, + pub labels: Option>, + pub merge_base: Option, + pub merge_commit_sha: Option, + pub mergeable: Option, + pub merged: Option, + pub merged_at: Option, + pub merged_by: Option, + pub milestone: Option, + pub number: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub patch_url: Option, + pub pin_order: Option, + pub requested_reviewers: Option>, + pub state: Option, + pub title: Option, + pub updated_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub user: Option, + } + + /// PullRequestMeta PR info if an issue is a PR + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PullRequestMeta { + pub merged: Option, + pub merged_at: Option, + } + + /// PullReview represents a pull request review + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PullReview { + pub body: Option, + pub comments_count: Option, + pub commit_id: Option, + pub dismissed: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub official: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub pull_request_url: Option, + pub stale: Option, + pub state: Option, + pub submitted_at: Option, + pub team: Option, + pub updated_at: Option, + pub user: Option, + } + + /// PullReviewComment represents a comment on a pull request review + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PullReviewComment { + pub body: Option, + pub commit_id: Option, + pub created_at: Option, + pub diff_hunk: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub original_commit_id: Option, + pub original_position: Option, + pub path: Option, + pub position: Option, + pub pull_request_review_id: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub pull_request_url: Option, + pub resolver: Option, + pub updated_at: Option, + pub user: Option, + } + + /// PullReviewRequestOptions are options to add or remove pull review requests + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PullReviewRequestOptions { + pub reviewers: Option>, + pub team_reviewers: Option>, + } + + /// PushMirror represents information of a push mirror + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct PushMirror { + pub created: Option, + pub interval: Option, + pub last_error: Option, + pub last_update: Option, + pub remote_address: Option, + pub remote_name: Option, + pub repo_name: Option, + pub sync_on_commit: Option, + } + + /// Reaction contain one reaction + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Reaction { + pub content: Option, + pub created_at: Option, + pub user: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Reference { + pub object: Option, + #[serde(rename = "ref")] + pub r#ref: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + } + + /// Release represents a repository release + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Release { + pub assets: Option>, + pub author: Option, + pub body: Option, + pub created_at: Option, + pub draft: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub name: Option, + pub prerelease: Option, + pub published_at: Option, + pub tag_name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub tarball_url: Option, + pub target_commitish: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub upload_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub zipball_url: Option, + } + + /// RenameUserOption options when renaming a user + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RenameUserOption { + pub new_username: String, + } + + /// RepoCollaboratorPermission to get repository permission for a collaborator + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RepoCollaboratorPermission { + pub permission: Option, + pub role_name: Option, + pub user: Option, + } + + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RepoCommit { + pub author: Option, + pub committer: Option, + pub message: Option, + pub tree: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub verification: Option, + } + + /// RepoTopicOptions a collection of repo topic names + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RepoTopicOptions { + pub topics: Option>, + } + + /// RepoTransfer represents a pending repo transfer + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RepoTransfer { + pub doer: Option, + pub recipient: Option, + pub teams: Option>, + } + + /// Repository represents a repository + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Repository { + pub allow_merge_commits: Option, + pub allow_rebase: Option, + pub allow_rebase_explicit: Option, + pub allow_rebase_update: Option, + pub allow_squash_merge: Option, + pub archived: Option, + pub archived_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub avatar_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub clone_url: Option, + pub created_at: Option, + pub default_allow_maintainer_edit: Option, + pub default_branch: Option, + pub default_delete_branch_after_merge: Option, + pub default_merge_style: Option, + pub description: Option, + pub empty: Option, + pub external_tracker: Option, + pub external_wiki: Option, + pub fork: Option, + pub forks_count: Option, + pub full_name: Option, + pub has_actions: Option, + pub has_issues: Option, + pub has_packages: Option, + pub has_projects: Option, + pub has_pull_requests: Option, + pub has_releases: Option, + pub has_wiki: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + pub ignore_whitespace_conflicts: Option, + pub internal: Option, + pub internal_tracker: Option, + pub language: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub languages_url: Option, + pub link: Option, + pub mirror: Option, + pub mirror_interval: Option, + pub mirror_updated: Option, + pub name: Option, + pub open_issues_count: Option, + pub open_pr_counter: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub original_url: Option, + pub owner: Option, + pub parent: Option>, + pub permissions: Option, + pub private: Option, + pub release_counter: Option, + pub repo_transfer: Option, + pub size: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub ssh_url: Option, + pub stars_count: Option, + pub template: Option, + pub updated_at: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub url: Option, + pub watchers_count: Option, + pub website: Option, + } + + /// RepositoryMeta basic repository information + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct RepositoryMeta { + pub full_name: Option, + pub id: Option, + pub name: Option, + pub owner: Option, + } + + /// ReviewStateType review state type + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ReviewStateType {} + + /// SearchResults results of a successful search + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct SearchResults { + pub data: Option>, + pub ok: Option, + } + + /// Secret represents a secret + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Secret { + pub created_at: Option, + pub name: Option, + } + + /// ServerVersion wraps the version of the server + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct ServerVersion { + pub version: Option, + } + + /// StateType issue state type + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct StateType {} + + /// StopWatch represent a running stopwatch + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct StopWatch { + pub created: Option, + pub duration: Option, + pub issue_index: Option, + pub issue_title: Option, + pub repo_name: Option, + pub repo_owner_name: Option, + pub seconds: Option, + } + + /// SubmitPullReviewOptions are options to submit a pending pull review + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct SubmitPullReviewOptions { + pub body: Option, + pub event: Option, + } + + /// Tag represents a repository tag + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Tag { + pub commit: Option, + pub id: Option, + pub message: Option, + pub name: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub tarball_url: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub zipball_url: Option, + } + + /// Team represents a team in an organization + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct Team { + pub can_create_org_repo: Option, + pub description: Option, + pub id: Option, + pub includes_all_repositories: Option, + pub name: Option, + pub organization: Option, + pub permission: Option, + pub units: Option>, + pub units_map: Option>, + } + + /// TimeStamp defines a timestamp + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct TimeStamp {} + + /// TimelineComment represents a timeline comment (comment of any type) on a commit or issue + /// + #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] + pub struct TimelineComment { + pub assignee: Option, + pub assignee_team: Option, + pub body: Option, + pub created_at: Option, + pub dependent_issue: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub html_url: Option, + pub id: Option, + #[serde(deserialize_with = "crate::none_if_blank_url")] + pub issue_url: Option, + pub label: Option