diff --git a/Cargo.lock b/Cargo.lock
index b64f534..edfc2e7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -201,7 +201,7 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
 name = "forgejo-api"
-version = "0.3.2"
+version = "0.2.0"
 dependencies = [
  "base64ct",
  "bytes",
diff --git a/Cargo.toml b/Cargo.toml
index 11d36ef..94f5e81 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 workspace = { members = ["generator"] }
 [package]
 name = "forgejo-api"
-version = "0.3.2"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 repository = "https://codeberg.org/Cyborus/forgejo-api"
diff --git a/generator/src/openapi.rs b/generator/src/openapi.rs
index 0678b59..35dd9ba 100644
--- a/generator/src/openapi.rs
+++ b/generator/src/openapi.rs
@@ -1079,9 +1079,6 @@ pub struct Schema {
     pub xml: Option<Xml>,
     pub external_docs: Option<ExternalDocs>,
     pub example: Option<serde_json::Value>,
-
-    #[serde(flatten)]
-    pub extensions: BTreeMap<String, serde_json::Value>,
 }
 
 impl JsonDeref for Schema {
diff --git a/generator/src/structs.rs b/generator/src/structs.rs
index 6a74dc1..4c78fac 100644
--- a/generator/src/structs.rs
+++ b/generator/src/structs.rs
@@ -1,7 +1,7 @@
 use crate::openapi::*;
 use eyre::WrapErr;
 use heck::ToPascalCase;
-use std::{collections::BTreeMap, fmt::Write};
+use std::fmt::Write;
 
 pub fn create_structs(spec: &OpenApiV2) -> eyre::Result<String> {
     let mut s = String::new();
@@ -51,13 +51,6 @@ pub fn create_struct_for_definition(
 
     let mut subtypes = Vec::new();
 
-    let parse_with = schema
-        .extensions
-        .get("x-parse-with")
-        .map(|ex| serde_json::from_value::<BTreeMap<String, String>>(ex.clone()))
-        .transpose()?
-        .unwrap_or_default();
-
     let docs = create_struct_docs(schema)?;
     let mut fields = String::new();
     let required = schema.required.as_deref().unwrap_or_default();
@@ -97,11 +90,6 @@ pub fn create_struct_for_definition(
             if field_ty == "Option<time::OffsetDateTime>" {
                 fields.push_str("#[serde(with = \"time::serde::rfc3339::option\")]\n");
             }
-            if let Some(parse_method) = parse_with.get(prop_name) {
-                fields.push_str("#[serde(deserialize_with = \"crate::");
-                fields.push_str(parse_method);
-                fields.push_str("\")]\n");
-            }
             if let MaybeRef::Value { value } = &prop_schema {
                 if let Some(desc) = &value.description {
                     for line in desc.lines() {
diff --git a/src/generated/methods.rs b/src/generated/methods.rs
index 96a3e18..c2404c9 100644
--- a/src/generated/methods.rs
+++ b/src/generated/methods.rs
@@ -7066,7 +7066,7 @@ impl crate::Forgejo {
     }
 
     /// Get user settings
-    pub async fn get_user_settings(&self) -> Result<UserSettings, ForgejoError> {
+    pub async fn get_user_settings(&self) -> Result<Vec<UserSettings>, ForgejoError> {
         let request = self.get("user/settings").build()?;
         let response = self.execute(request).await?;
         match response.status().as_u16() {
@@ -7081,7 +7081,7 @@ impl crate::Forgejo {
     pub async fn update_user_settings(
         &self,
         body: UserSettingsOptions,
-    ) -> Result<UserSettings, ForgejoError> {
+    ) -> Result<Vec<UserSettings>, ForgejoError> {
         let request = self.patch("user/settings").json(&body).build()?;
         let response = self.execute(request).await?;
         match response.status().as_u16() {
diff --git a/src/generated/structs.rs b/src/generated/structs.rs
index 45f767b..f7b8ce8 100644
--- a/src/generated/structs.rs
+++ b/src/generated/structs.rs
@@ -2034,7 +2034,6 @@ pub struct PullRequest {
     #[serde(deserialize_with = "crate::none_if_blank_url")]
     pub patch_url: Option<url::Url>,
     pub pin_order: Option<u64>,
-    #[serde(deserialize_with = "crate::requested_reviewers_ignore_null")]
     pub requested_reviewers: Option<Vec<User>>,
     pub state: Option<StateType>,
     pub title: Option<String>,
@@ -2541,7 +2540,7 @@ pub struct User {
     /// the user's full name
     pub full_name: Option<String>,
     /// the user's id
-    pub id: Option<i64>,
+    pub id: Option<u64>,
     /// Is the user an administrator
     pub is_admin: Option<bool>,
     /// User locale
diff --git a/src/lib.rs b/src/lib.rs
index abbb8a5..d9b877e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -358,18 +358,6 @@ where
         .or(Ok(None))
 }
 
-fn requested_reviewers_ignore_null<'de, D, DE>(
-    deserializer: D,
-) -> Result<Option<Vec<structs::User>>, DE>
-where
-    D: Deserializer<'de>,
-    DE: serde::de::Error,
-{
-    let list: Option<Vec<Option<structs::User>>> =
-        Option::deserialize(deserializer).map_err(DE::custom)?;
-    Ok(list.map(|list| list.into_iter().filter_map(|x| x).collect::<Vec<_>>()))
-}
-
 fn parse_ssh_url(raw_url: &String) -> Result<Url, url::ParseError> {
     // in case of a non-standard ssh-port (not 22), the ssh url coming from the forgejo API
     // is actually parseable by the url crate, so try to do that first
diff --git a/swagger.v1.json b/swagger.v1.json
index fad9e63..0de864a 100644
--- a/swagger.v1.json
+++ b/swagger.v1.json
@@ -20667,10 +20667,7 @@
           "$ref": "#/definitions/User"
         }
       },
-      "x-go-package": "code.gitea.io/gitea/modules/structs",
-      "x-parse-with": {
-        "requested_reviewers": "requested_reviewers_ignore_null"
-      }
+      "x-go-package": "code.gitea.io/gitea/modules/structs"
     },
     "PullRequestMeta": {
       "description": "PullRequestMeta PR info if an issue is a PR",
@@ -23167,7 +23164,10 @@
     "UserSettings": {
       "description": "UserSettings",
       "schema": {
-        "$ref": "#/definitions/UserSettings"
+        "type": "array",
+        "items": {
+          "$ref": "#/definitions/UserSettings"
+        }
       }
     },
     "WatchInfo": {
diff --git a/tests/repo.rs b/tests/repo.rs
index 16566da..004cb8e 100644
--- a/tests/repo.rs
+++ b/tests/repo.rs
@@ -20,7 +20,7 @@ impl Git {
     }
 }
 
-async fn setup_local_repo(git: &Git) {
+async fn basic_repo(api: &forgejo_api::Forgejo, git: &Git, name: &str) -> Repository {
     git.run(&["config", "--global", "init.defaultBranch", "main"]);
     git.run(&["init"]);
     git.run(&["config", "user.name", "TestingAdmin"]);
@@ -30,10 +30,7 @@ async fn setup_local_repo(git: &Git) {
         .unwrap();
     git.run(&["add", "."]);
     git.run(&["commit", "-m", "initial commit"]);
-}
 
-async fn basic_repo(api: &forgejo_api::Forgejo, git: &Git, name: &str) -> Repository {
-    setup_local_repo(git).await;
     let repo_opt = CreateRepoOption {
         auto_init: Some(false),
         default_branch: Some("main".into()),
@@ -71,51 +68,6 @@ async fn basic_repo(api: &forgejo_api::Forgejo, git: &Git, name: &str) -> Reposi
     remote_repo
 }
 
-async fn basic_org_repo(
-    api: &forgejo_api::Forgejo,
-    git: &Git,
-    org: &str,
-    name: &str,
-) -> Repository {
-    setup_local_repo(git).await;
-
-    let repo_opt = CreateRepoOption {
-        auto_init: Some(false),
-        default_branch: Some("main".into()),
-        description: Some("Test Repo".into()),
-        gitignores: Some("".into()),
-        issue_labels: Some("".into()),
-        license: Some("".into()),
-        name: name.into(),
-        object_format_name: None,
-        private: Some(false),
-        readme: None,
-        template: Some(false),
-        trust_model: Some(CreateRepoOptionTrustModel::Default),
-    };
-    let remote_repo = api.create_org_repo(org, repo_opt).await.unwrap();
-    assert!(
-        remote_repo.has_pull_requests.unwrap(),
-        "repo does not accept pull requests"
-    );
-    assert!(
-        remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == org,
-        "repo owner is not \"TestingAdmin\""
-    );
-    assert!(
-        remote_repo.name.as_ref().unwrap() == name,
-        "repo name is not \"{name}\""
-    );
-
-    let mut remote_url = remote_repo.clone_url.clone().unwrap();
-    remote_url.set_username("TestingAdmin").unwrap();
-    remote_url.set_password(Some("password")).unwrap();
-    git.run(&["remote", "add", "origin", remote_url.as_str()]);
-    git.run(&["push", "-u", "origin", "main"]);
-
-    remote_repo
-}
-
 #[tokio::test]
 async fn pull_request() {
     let api = common::login();
@@ -322,66 +274,3 @@ async fn delete_repo() {
         .await
         .expect("failed to delete repo");
 }
-
-#[tokio::test]
-async fn team_pr_review_request() {
-    let api = common::login();
-
-    let org_opt = CreateOrgOption {
-        description: Some("Testing team review requests".into()),
-        email: None,
-        full_name: None,
-        location: None,
-        repo_admin_change_team_access: None,
-        username: "team-review-org".into(),
-        visibility: None,
-        website: None,
-    };
-    api.org_create(org_opt).await.unwrap();
-
-    let git = Git::new("./test_repos/team-pr-review");
-    let _ = basic_org_repo(&api, &git, "team-review-org", "team-pr-review").await;
-
-    git.run(&["switch", "-c", "test"]);
-    tokio::fs::write(
-        "./test_repos/team-pr-review/example.rs",
-        "fn add_one(x: u32) -> u32 { x + 1 }",
-    )
-    .await
-    .unwrap();
-    git.run(&["add", "."]);
-    git.run(&["commit", "-m", "egg"]);
-    git.run(&["push", "-u", "origin", "test"]);
-
-    let pr_opt = CreatePullRequestOption {
-        assignee: None,
-        assignees: Some(vec!["TestingAdmin".into()]),
-        base: Some("main".into()),
-        body: Some("This is a test PR".into()),
-        due_date: None,
-        head: Some("test".into()),
-        labels: None,
-        milestone: None,
-        title: Some("test pr".into()),
-    };
-
-    // Wait for... something to happen, or else creating a PR will return 404
-    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
-    api.repo_create_pull_request("team-review-org", "team-pr-review", pr_opt)
-        .await
-        .expect("couldn't create pr");
-
-    let review_opt = PullReviewRequestOptions {
-        reviewers: None,
-        team_reviewers: Some(vec!["Owners".into()]),
-    };
-    api.repo_create_pull_review_requests("team-review-org", "team-pr-review", 1, review_opt)
-        .await
-        .expect("couldn't request review");
-
-    let pr = api
-        .repo_get_pull_request("team-review-org", "team-pr-review", 1)
-        .await
-        .expect("couldn't get pr");
-    assert_eq!(pr.requested_reviewers, Some(Vec::new()));
-}