Merge pull request 'update to forgejo 9' (#75) from forgejo-9 into mainHEADmain

Reviewed-on: https://codeberg.org/Cyborus/forgejo-api/pulls/75

2 files changed, 903 insertions, 57 deletions

diff --git a/src/generated/methods.rs b/src/generated/methods.rs
index 2b23abf..f49d61f 100644
--- a/src/generated/methods.rs
+++ b/src/generated/methods.rs
@@ -3,6 +3,26 @@ use crate::ForgejoError;
 use std::collections::BTreeMap;
 
 impl crate::Forgejo {
+    /// Returns the instance's Actor
+    pub async fn activitypub_instance_actor(&self) -> Result<ActivityPub, ForgejoError> {
+        let request = self.get("activitypub/actor").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
+    pub async fn activitypub_instance_actor_inbox(&self) -> Result<(), ForgejoError> {
+        let request = self.post("activitypub/actor/inbox").build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
     /// Returns the Repository actor for a repo
     ///
     /// - `repository-id`: repository ID of the repo
@@ -206,6 +226,239 @@ impl crate::Forgejo {
         }
     }
 
+    /// List the available quota groups
+    pub async fn admin_list_quota_groups(&self) -> Result<Vec<QuotaGroup>, ForgejoError> {
+        let request = self.get("admin/quota/groups").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 quota group
+    ///
+    /// - `group`: Definition of the quota group
+
+    ///   See [`CreateQuotaGroupOptions`]
+    pub async fn admin_create_quota_group(
+        &self,
+        group: CreateQuotaGroupOptions,
+    ) -> Result<QuotaGroup, ForgejoError> {
+        let request = self.post("admin/quota/groups").json(&group).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            201 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Get information about the quota group
+    ///
+    /// - `quotagroup`: quota group to query
+    pub async fn admin_get_quota_group(
+        &self,
+        quotagroup: &str,
+    ) -> Result<QuotaGroup, ForgejoError> {
+        let request = self
+            .get(&format!("admin/quota/groups/{quotagroup}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Delete a quota group
+    ///
+    /// - `quotagroup`: quota group to delete
+    pub async fn admin_delete_quota_group(&self, quotagroup: &str) -> Result<(), ForgejoError> {
+        let request = self
+            .delete(&format!("admin/quota/groups/{quotagroup}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Adds a rule to a quota group
+    ///
+    /// - `quotagroup`: quota group to add a rule to
+    /// - `quotarule`: the name of the quota rule to add to the group
+    pub async fn admin_add_rule_to_quota_group(
+        &self,
+        quotagroup: &str,
+        quotarule: &str,
+    ) -> Result<(), ForgejoError> {
+        let request = self
+            .put(&format!(
+                "admin/quota/groups/{quotagroup}/rules/{quotarule}"
+            ))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Removes a rule from a quota group
+    ///
+    /// - `quotagroup`: quota group to remove a rule from
+    /// - `quotarule`: the name of the quota rule to remove from the group
+    pub async fn admin_remove_rule_from_quota_group(
+        &self,
+        quotagroup: &str,
+        quotarule: &str,
+    ) -> Result<(), ForgejoError> {
+        let request = self
+            .delete(&format!(
+                "admin/quota/groups/{quotagroup}/rules/{quotarule}"
+            ))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List users in a quota group
+    ///
+    /// - `quotagroup`: quota group to list members of
+    pub async fn admin_list_users_in_quota_group(
+        &self,
+        quotagroup: &str,
+    ) -> Result<Vec<User>, ForgejoError> {
+        let request = self
+            .get(&format!("admin/quota/groups/{quotagroup}/users"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Add a user to a quota group
+    ///
+    /// - `quotagroup`: quota group to add the user to
+    /// - `username`: username of the user to add to the quota group
+    pub async fn admin_add_user_to_quota_group(
+        &self,
+        quotagroup: &str,
+        username: &str,
+    ) -> Result<(), ForgejoError> {
+        let request = self
+            .put(&format!("admin/quota/groups/{quotagroup}/users/{username}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Remove a user from a quota group
+    ///
+    /// - `quotagroup`: quota group to remove a user from
+    /// - `username`: username of the user to remove from the quota group
+    pub async fn admin_remove_user_from_quota_group(
+        &self,
+        quotagroup: &str,
+        username: &str,
+    ) -> Result<(), ForgejoError> {
+        let request = self
+            .delete(&format!("admin/quota/groups/{quotagroup}/users/{username}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the available quota rules
+    pub async fn admin_list_quota_rules(&self) -> Result<Vec<QuotaRuleInfo>, ForgejoError> {
+        let request = self.get("admin/quota/rules").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 quota rule
+    ///
+    /// - `rule`: Definition of the quota rule
+
+    ///   See [`CreateQuotaRuleOptions`]
+    pub async fn admin_create_quota_rule(
+        &self,
+        rule: CreateQuotaRuleOptions,
+    ) -> Result<QuotaRuleInfo, ForgejoError> {
+        let request = self.post("admin/quota/rules").json(&rule).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            201 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Get information about a quota rule
+    ///
+    /// - `quotarule`: quota rule to query
+    pub async fn admin_get_quota_rule(
+        &self,
+        quotarule: &str,
+    ) -> Result<QuotaRuleInfo, ForgejoError> {
+        let request = self
+            .get(&format!("admin/quota/rules/{quotarule}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Deletes a quota rule
+    ///
+    /// - `quotarule`: quota rule to delete
+    pub async fn admin_delete_quota_rule(&self, quotarule: &str) -> Result<(), ForgejoError> {
+        let request = self
+            .delete(&format!("admin/quota/rules/{quotarule}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Change an existing quota rule
+    ///
+    /// - `quotarule`: Quota rule to change
+    /// - `rule`: See [`EditQuotaRuleOptions`]
+    pub async fn admin_edit_quota_rule(
+        &self,
+        quotarule: &str,
+        rule: EditQuotaRuleOptions,
+    ) -> Result<QuotaRuleInfo, ForgejoError> {
+        let request = self
+            .patch(&format!("admin/quota/rules/{quotarule}"))
+            .json(&rule)
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
     /// Get an global actions runner registration token
     pub async fn admin_get_runner_registration_token(
         &self,
@@ -393,6 +646,40 @@ impl crate::Forgejo {
         }
     }
 
+    /// Get the user's quota info
+    ///
+    /// - `username`: username of user to query
+    pub async fn admin_get_user_quota(&self, username: &str) -> Result<QuotaInfo, ForgejoError> {
+        let request = self.get(&format!("admin/users/{username}/quota")).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// Set the user's quota groups to a given list.
+    ///
+    /// - `username`: username of the user to modify the quota groups from
+    /// - `groups`: list of groups that the user should be a member of
+
+    ///   See [`SetUserQuotaGroupsOptions`]
+    pub async fn admin_set_user_quota_groups(
+        &self,
+        username: &str,
+        groups: SetUserQuotaGroupsOptions,
+    ) -> Result<(), ForgejoError> {
+        let request = self
+            .post(&format!("admin/users/{username}/quota/groups"))
+            .json(&groups)
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            204 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
     /// Rename a user
     ///
     /// - `username`: existing username of user
@@ -1256,6 +1543,84 @@ impl crate::Forgejo {
         }
     }
 
+    /// Get quota information for an organization
+    ///
+    /// - `org`: name of the organization
+    pub async fn org_get_quota(&self, org: &str) -> Result<QuotaInfo, ForgejoError> {
+        let request = self.get(&format!("orgs/{org}/quota")).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the artifacts affecting the organization's quota
+    ///
+    /// - `org`: name of the organization
+    pub async fn org_list_quota_artifacts(
+        &self,
+        org: &str,
+        query: OrgListQuotaArtifactsQuery,
+    ) -> Result<Vec<QuotaUsedArtifact>, ForgejoError> {
+        let request = self
+            .get(&format!("orgs/{org}/quota/artifacts?{query}"))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the attachments affecting the organization's quota
+    ///
+    /// - `org`: name of the organization
+    pub async fn org_list_quota_attachments(
+        &self,
+        org: &str,
+        query: OrgListQuotaAttachmentsQuery,
+    ) -> Result<Vec<QuotaUsedAttachment>, ForgejoError> {
+        let request = self
+            .get(&format!("orgs/{org}/quota/attachments?{query}"))
+            .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 organization is over quota for a given subject
+    ///
+    /// - `org`: name of the organization
+    pub async fn org_check_quota(&self, org: &str) -> Result<(), ForgejoError> {
+        let request = self.get(&format!("orgs/{org}/quota/check")).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the packages affecting the organization's quota
+    ///
+    /// - `org`: name of the organization
+    pub async fn org_list_quota_packages(
+        &self,
+        org: &str,
+        query: OrgListQuotaPackagesQuery,
+    ) -> Result<Vec<QuotaUsedPackage>, ForgejoError> {
+        let request = self
+            .get(&format!("orgs/{org}/quota/packages?{query}"))
+            .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 repos
     ///
     /// - `org`: name of the organization
@@ -1533,6 +1898,27 @@ impl crate::Forgejo {
         }
     }
 
+    /// Get a repository's actions runner registration token
+    ///
+    /// - `owner`: owner of the repo
+    /// - `repo`: name of the repo
+    pub async fn repo_get_runner_registration_token(
+        &self,
+        owner: &str,
+        repo: &str,
+    ) -> Result<RegistrationTokenHeaders, ForgejoError> {
+        let request = self
+            .get(&format!(
+                "repos/{owner}/{repo}/actions/runners/registration-token"
+            ))
+            .build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.headers().try_into()?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
     /// List an repo's actions secrets
     ///
     /// - `owner`: owner of the repository
@@ -3235,20 +3621,19 @@ impl crate::Forgejo {
         attachment: Vec<u8>,
         query: IssueCreateIssueCommentAttachmentQuery,
     ) -> Result<Attachment, ForgejoError> {
-        let request = self
-            .post(&format!(
-                "repos/{owner}/{repo}/issues/comments/{id}/assets?{query}"
-            ))
-            .multipart(
-                reqwest::multipart::Form::new().part(
-                    "attachment",
-                    reqwest::multipart::Part::bytes(attachment)
-                        .file_name("file")
-                        .mime_str("*/*")
-                        .unwrap(),
-                ),
-            )
-            .build()?;
+        let builder = self.post(&format!(
+            "repos/{owner}/{repo}/issues/comments/{id}/assets?{query}"
+        ));
+        let builder = builder.multipart(
+            reqwest::multipart::Form::new().part(
+                "attachment",
+                reqwest::multipart::Part::bytes(attachment)
+                    .file_name("file")
+                    .mime_str("*/*")
+                    .unwrap(),
+            ),
+        );
+        let request = builder.build()?;
         let response = self.execute(request).await?;
         match response.status().as_u16() {
             201 => Ok(response.json().await?),
@@ -3530,20 +3915,19 @@ impl crate::Forgejo {
         attachment: Vec<u8>,
         query: IssueCreateIssueAttachmentQuery,
     ) -> Result<Attachment, ForgejoError> {
-        let request = self
-            .post(&format!(
-                "repos/{owner}/{repo}/issues/{index}/assets?{query}"
-            ))
-            .multipart(
-                reqwest::multipart::Form::new().part(
-                    "attachment",
-                    reqwest::multipart::Part::bytes(attachment)
-                        .file_name("file")
-                        .mime_str("*/*")
-                        .unwrap(),
-                ),
-            )
-            .build()?;
+        let builder = self.post(&format!(
+            "repos/{owner}/{repo}/issues/{index}/assets?{query}"
+        ));
+        let builder = builder.multipart(
+            reqwest::multipart::Form::new().part(
+                "attachment",
+                reqwest::multipart::Part::bytes(attachment)
+                    .file_name("file")
+                    .mime_str("*/*")
+                    .unwrap(),
+            ),
+        );
+        let request = builder.build()?;
         let response = self.execute(request).await?;
         match response.status().as_u16() {
             201 => Ok(response.json().await?),
@@ -5791,20 +6175,22 @@ impl crate::Forgejo {
     /// - `owner`: owner of the repo
     /// - `repo`: name of the repo
     /// - `id`: id of the release
-    /// - `attachment`: attachment to upload
+    /// - `attachment`: attachment to upload (this parameter is incompatible with `external_url`)
+    /// - `external_url`: url to external asset (this parameter is incompatible with `attachment`)
     pub async fn repo_create_release_attachment(
         &self,
         owner: &str,
         repo: &str,
         id: u64,
-        attachment: Vec<u8>,
+        attachment: Option<Vec<u8>>,
+        external_url: Option<Vec<u8>>,
         query: RepoCreateReleaseAttachmentQuery,
     ) -> Result<Attachment, ForgejoError> {
-        let request = self
-            .post(&format!(
-                "repos/{owner}/{repo}/releases/{id}/assets?{query}"
-            ))
-            .multipart(
+        let builder = self.post(&format!(
+            "repos/{owner}/{repo}/releases/{id}/assets?{query}"
+        ));
+        let builder = match attachment {
+            Some(attachment) => builder.multipart(
                 reqwest::multipart::Form::new().part(
                     "attachment",
                     reqwest::multipart::Part::bytes(attachment)
@@ -5812,8 +6198,22 @@ impl crate::Forgejo {
                         .mime_str("*/*")
                         .unwrap(),
                 ),
-            )
-            .build()?;
+            ),
+            None => builder,
+        };
+        let builder = match external_url {
+            Some(external_url) => builder.multipart(
+                reqwest::multipart::Form::new().part(
+                    "attachment",
+                    reqwest::multipart::Part::bytes(external_url)
+                        .file_name("file")
+                        .mime_str("*/*")
+                        .unwrap(),
+                ),
+            ),
+            None => builder,
+        };
+        let request = builder.build()?;
         let response = self.execute(request).await?;
         match response.status().as_u16() {
             201 => Ok(response.json().await?),
@@ -5918,25 +6318,6 @@ impl crate::Forgejo {
         }
     }
 
-    /// Get a repository's actions runner registration token
-    ///
-    /// - `owner`: owner of the repo
-    /// - `repo`: name of the repo
-    pub async fn repo_get_runner_registration_token(
-        &self,
-        owner: &str,
-        repo: &str,
-    ) -> Result<RegistrationTokenHeaders, ForgejoError> {
-        let request = self
-            .get(&format!("repos/{owner}/{repo}/runners/registration-token"))
-            .build()?;
-        let response = self.execute(request).await?;
-        match response.status().as_u16() {
-            200 => Ok(response.headers().try_into()?),
-            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
-        }
-    }
-
     /// Get signing-key.gpg for given repository
     ///
     /// - `owner`: owner of the repo
@@ -7583,6 +7964,70 @@ impl crate::Forgejo {
         }
     }
 
+    /// Get quota information for the authenticated user
+    pub async fn user_get_quota(&self) -> Result<QuotaInfo, ForgejoError> {
+        let request = self.get("user/quota").build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the artifacts affecting the authenticated user's quota
+    ///
+    pub async fn user_list_quota_artifacts(
+        &self,
+        query: UserListQuotaArtifactsQuery,
+    ) -> Result<Vec<QuotaUsedArtifact>, ForgejoError> {
+        let request = self.get(&format!("user/quota/artifacts?{query}")).build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(response.json().await?),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the attachments affecting the authenticated user's quota
+    ///
+    pub async fn user_list_quota_attachments(
+        &self,
+        query: UserListQuotaAttachmentsQuery,
+    ) -> Result<Vec<QuotaUsedAttachment>, ForgejoError> {
+        let request = self
+            .get(&format!("user/quota/attachments?{query}"))
+            .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 authenticated user is over quota for a given subject
+    pub async fn user_check_quota(&self) -> Result<(), ForgejoError> {
+        let request = self.get("user/quota/check").build()?;
+        let response = self.execute(request).await?;
+        match response.status().as_u16() {
+            200 => Ok(()),
+            _ => Err(ForgejoError::UnexpectedStatusCode(response.status())),
+        }
+    }
+
+    /// List the packages affecting the authenticated user's quota
+    ///
+    pub async fn user_list_quota_packages(
+        &self,
+        query: UserListQuotaPackagesQuery,
+    ) -> Result<Vec<QuotaUsedPackage>, ForgejoError> {
+        let request = self.get(&format!("user/quota/packages?{query}")).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(
diff --git a/src/generated/structs.rs b/src/generated/structs.rs
index b99c2a0..a65f45d 100644
--- a/src/generated/structs.rs
+++ b/src/generated/structs.rs
@@ -147,9 +147,18 @@ pub struct ActivityPub {
 /// AddCollaboratorOption options when adding a user as a collaborator of a repository
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct AddCollaboratorOption {
-    pub permission: Option<String>,
+    pub permission: Option<AddCollaboratorOptionPermission>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum AddCollaboratorOptionPermission {
+    #[serde(rename = "read")]
+    Read,
+    #[serde(rename = "write")]
+    Write,
+    #[serde(rename = "admin")]
+    Admin,
+}
 /// AddTimeOption options for adding time to an issue
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct AddTimeOption {
@@ -196,9 +205,18 @@ pub struct Attachment {
     pub id: Option<i64>,
     pub name: Option<String>,
     pub size: Option<i64>,
+    #[serde(rename = "type")]
+    pub r#type: Option<AttachmentType>,
     pub uuid: Option<String>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum AttachmentType {
+    #[serde(rename = "attachment")]
+    Attachment,
+    #[serde(rename = "external")]
+    External,
+}
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BlockedUser {
     pub block_id: Option<i64>,
@@ -767,8 +785,62 @@ pub struct CreatePushMirrorOption {
     pub remote_password: Option<String>,
     pub remote_username: Option<String>,
     pub sync_on_commit: Option<bool>,
+    pub use_ssh: Option<bool>,
 }
 
+/// CreateQutaGroupOptions represents the options for creating a quota group
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct CreateQuotaGroupOptions {
+    /// Name of the quota group to create
+    pub name: Option<String>,
+    /// Rules to add to the newly created group.
+    ///
+    /// If a rule does not exist, it will be created.
+    pub rules: Option<Vec<CreateQuotaRuleOptions>>,
+}
+
+/// CreateQuotaRuleOptions represents the options for creating a quota rule
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct CreateQuotaRuleOptions {
+    /// The limit set by the rule
+    pub limit: Option<i64>,
+    /// Name of the rule to create
+    pub name: Option<String>,
+    /// The subjects affected by the rule
+    pub subjects: Option<Vec<CreateQuotaRuleOptionsSubjects>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum CreateQuotaRuleOptionsSubjects {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "size:all")]
+    SizeAll,
+    #[serde(rename = "size:repos:all")]
+    SizeReposAll,
+    #[serde(rename = "size:repos:public")]
+    SizeReposPublic,
+    #[serde(rename = "size:repos:private")]
+    SizeReposPrivate,
+    #[serde(rename = "size:git:all")]
+    SizeGitAll,
+    #[serde(rename = "size:git:lfs")]
+    SizeGitLfs,
+    #[serde(rename = "size:assets:all")]
+    SizeAssetsAll,
+    #[serde(rename = "size:assets:attachments:all")]
+    SizeAssetsAttachmentsAll,
+    #[serde(rename = "size:assets:attachments:issues")]
+    SizeAssetsAttachmentsIssues,
+    #[serde(rename = "size:assets:attachments:releases")]
+    SizeAssetsAttachmentsReleases,
+    #[serde(rename = "size:assets:artifacts")]
+    SizeAssetsArtifacts,
+    #[serde(rename = "size:assets:packages:all")]
+    SizeAssetsPackagesAll,
+    #[serde(rename = "size:assets:wiki")]
+    SizeAssetsWiki,
+}
 /// CreateReleaseOption options when creating a release
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CreateReleaseOption {
@@ -1004,6 +1076,9 @@ pub struct DispatchWorkflowOption {
 /// EditAttachmentOptions options for editing attachments
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EditAttachmentOptions {
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// (Can only be set if existing attachment is of external type)
+    pub browser_download_url: Option<url::Url>,
     pub name: Option<String>,
 }
 
@@ -1146,6 +1221,15 @@ pub struct EditPullRequestOption {
     pub unset_due_date: Option<bool>,
 }
 
+/// EditQuotaRuleOptions represents the options for editing a quota rule
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EditQuotaRuleOptions {
+    /// The limit set by the rule
+    pub limit: Option<i64>,
+    /// The subjects affected by the rule
+    pub subjects: Option<Vec<String>>,
+}
+
 /// EditReactionOption contain the reaction type
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EditReactionOption {
@@ -2192,6 +2276,7 @@ pub struct PullRequest {
     pub pin_order: Option<i64>,
     #[serde(deserialize_with = "crate::requested_reviewers_ignore_null")]
     pub requested_reviewers: Option<Vec<User>>,
+    pub requested_reviewers_teams: Option<Vec<Team>>,
     /// number of review comments made on the diff of a PR review (not including comments on commits or issues in a PR)
     pub review_comments: Option<i64>,
     pub state: Option<StateType>,
@@ -2277,12 +2362,150 @@ pub struct PushMirror {
     pub last_error: Option<String>,
     #[serde(with = "time::serde::rfc3339::option")]
     pub last_update: Option<time::OffsetDateTime>,
+    pub public_key: Option<String>,
     pub remote_address: Option<String>,
     pub remote_name: Option<String>,
     pub repo_name: Option<String>,
     pub sync_on_commit: Option<bool>,
 }
 
+/// QuotaGroup represents a quota group
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaGroup {
+    /// Name of the group
+    pub name: Option<String>,
+    /// Rules associated with the group
+    pub rules: Option<Vec<QuotaRuleInfo>>,
+}
+
+/// QuotaInfo represents information about a user's quota
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaInfo {
+    pub groups: Option<Vec<QuotaGroup>>,
+    pub used: Option<QuotaUsed>,
+}
+
+/// QuotaRuleInfo contains information about a quota rule
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaRuleInfo {
+    /// The limit set by the rule
+    pub limit: Option<i64>,
+    /// Name of the rule (only shown to admins)
+    pub name: Option<String>,
+    /// Subjects the rule affects
+    pub subjects: Option<Vec<String>>,
+}
+
+/// QuotaUsed represents the quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsed {
+    pub size: Option<QuotaUsedSize>,
+}
+
+/// QuotaUsedArtifact represents an artifact counting towards a user's quota
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedArtifact {
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// HTML URL to the action run containing the artifact
+    pub html_url: Option<url::Url>,
+    /// Name of the artifact
+    pub name: Option<String>,
+    /// Size of the artifact (compressed)
+    pub size: Option<i64>,
+}
+
+/// QuotaUsedAttachment represents an attachment counting towards a user's quota
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedAttachment {
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// API URL for the attachment
+    pub api_url: Option<url::Url>,
+    /// Context for the attachment: URLs to the containing object
+    pub contained_in: Option<QuotaUsedAttachmentContainedIn>,
+    /// Filename of the attachment
+    pub name: Option<String>,
+    /// Size of the attachment (in bytes)
+    pub size: Option<i64>,
+}
+
+/// Context for the attachment: URLs to the containing object
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedAttachmentContainedIn {
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// API URL for the object that contains this attachment
+    pub api_url: Option<url::Url>,
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// HTML URL for the object that contains this attachment
+    pub html_url: Option<url::Url>,
+}
+
+/// QuotaUsedPackage represents a package counting towards a user's quota
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedPackage {
+    #[serde(deserialize_with = "crate::none_if_blank_url")]
+    /// HTML URL to the package version
+    pub html_url: Option<url::Url>,
+    /// Name of the package
+    pub name: Option<String>,
+    /// Size of the package version
+    pub size: Option<i64>,
+    /// Type of the package
+    #[serde(rename = "type")]
+    pub r#type: Option<String>,
+    /// Version of the package
+    pub version: Option<String>,
+}
+
+/// QuotaUsedSize represents the size-based quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSize {
+    pub assets: Option<QuotaUsedSizeAssets>,
+    pub git: Option<QuotaUsedSizeGit>,
+    pub repos: Option<QuotaUsedSizeRepos>,
+}
+
+/// QuotaUsedSizeAssets represents the size-based asset usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSizeAssets {
+    /// Storage size used for the user's artifacts
+    pub artifacts: Option<i64>,
+    pub attachments: Option<QuotaUsedSizeAssetsAttachments>,
+    pub packages: Option<QuotaUsedSizeAssetsPackages>,
+}
+
+/// QuotaUsedSizeAssetsAttachments represents the size-based attachment quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSizeAssetsAttachments {
+    /// Storage size used for the user's issue & comment attachments
+    pub issues: Option<i64>,
+    /// Storage size used for the user's release attachments
+    pub releases: Option<i64>,
+}
+
+/// QuotaUsedSizeAssetsPackages represents the size-based package quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSizeAssetsPackages {
+    /// Storage suze used for the user's packages
+    pub all: Option<i64>,
+}
+
+/// QuotaUsedSizeGit represents the size-based git (lfs) quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSizeGit {
+    /// Storage size of the user's Git LFS objects
+    #[serde(rename = "LFS")]
+    pub lfs: Option<i64>,
+}
+
+/// QuotaUsedSizeRepos represents the size-based repository quota usage of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct QuotaUsedSizeRepos {
+    /// Storage size of the user's private repositories
+    pub private: Option<i64>,
+    /// Storage size of the user's public repositories
+    pub public: Option<i64>,
+}
+
 /// Reaction contain one reaction
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct Reaction {
@@ -2491,6 +2714,13 @@ pub struct ServerVersion {
     pub version: Option<String>,
 }
 
+/// SetUserQuotaGroupsOptions represents the quota groups of a user
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct SetUserQuotaGroupsOptions {
+    /// Quota groups the user shall have
+    pub groups: Vec<String>,
+}
+
 /// StateType issue state type
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -3091,6 +3321,46 @@ impl TryFrom<&reqwest::header::HeaderMap> for InvalidTopicsErrorHeaders {
     }
 }
 
+pub struct QuotaExceededHeaders {
+    pub message: Option<String>,
+    pub user_id: Option<i64>,
+    pub username: Option<String>,
+}
+
+impl TryFrom<&reqwest::header::HeaderMap> for QuotaExceededHeaders {
+    type Error = StructureError;
+
+    fn try_from(map: &reqwest::header::HeaderMap) -> Result<Self, Self::Error> {
+        let message = map
+            .get("message")
+            .map(|s| -> Result<_, _> {
+                let s = s.to_str().map_err(|_| StructureError::HeaderNotAscii)?;
+                Ok(s.to_string())
+            })
+            .transpose()?;
+        let user_id = map
+            .get("user_id")
+            .map(|s| -> Result<_, _> {
+                let s = s.to_str().map_err(|_| StructureError::HeaderNotAscii)?;
+                s.parse::<i64>()
+                    .map_err(|_| StructureError::HeaderParseFailed)
+            })
+            .transpose()?;
+        let username = map
+            .get("username")
+            .map(|s| -> Result<_, _> {
+                let s = s.to_str().map_err(|_| StructureError::HeaderNotAscii)?;
+                Ok(s.to_string())
+            })
+            .transpose()?;
+        Ok(Self {
+            message,
+            user_id,
+            username,
+        })
+    }
+}
+
 pub struct RepoArchivedErrorHeaders {
     pub message: Option<String>,
     pub url: Option<url::Url>,
@@ -3682,6 +3952,69 @@ impl std::fmt::Display for OrgListPublicMembersQuery {
 }
 
 #[derive(Debug, Clone, PartialEq, Default)]
+pub struct OrgListQuotaArtifactsQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for OrgListQuotaArtifactsQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct OrgListQuotaAttachmentsQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for OrgListQuotaAttachmentsQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct OrgListQuotaPackagesQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for OrgListQuotaPackagesQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct OrgListReposQuery {
     /// page number of results to return (1-based)
     pub page: Option<u32>,
@@ -6072,11 +6405,76 @@ impl std::fmt::Display for OrgListCurrentUserOrgsQuery {
 }
 
 #[derive(Debug, Clone, PartialEq, Default)]
+pub struct UserListQuotaArtifactsQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for UserListQuotaArtifactsQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct UserListQuotaAttachmentsQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for UserListQuotaAttachmentsQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct UserListQuotaPackagesQuery {
+    /// page number of results to return (1-based)
+    pub page: Option<u32>,
+    /// page size of results
+    pub limit: Option<u32>,
+}
+
+impl std::fmt::Display for UserListQuotaPackagesQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(page) = &self.page {
+            write!(f, "page={page}&")?;
+        }
+        if let Some(limit) = &self.limit {
+            write!(f, "limit={limit}&")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct UserCurrentListReposQuery {
     /// page number of results to return (1-based)
     pub page: Option<u32>,
     /// page size of results
     pub limit: Option<u32>,
+    /// order the repositories by name (default), id, or size
+    pub order_by: Option<String>,
 }
 
 impl std::fmt::Display for UserCurrentListReposQuery {
@@ -6087,6 +6485,9 @@ impl std::fmt::Display for UserCurrentListReposQuery {
         if let Some(limit) = &self.limit {
             write!(f, "limit={limit}&")?;
         }
+        if let Some(order_by) = &self.order_by {
+            write!(f, "order_by={order_by}&")?;
+        }
 
         Ok(())
     }