diff --git a/src/BaseClient.ts b/src/BaseClient.ts
index 588d574..c5fa27a 100644
--- a/src/BaseClient.ts
+++ b/src/BaseClient.ts
@@ -1,8 +1,8 @@
 import type * as types from "./types";
 
 export interface BaseClientOptions {
-  fetchFunction: typeof fetch;
-  headers: Record<string, string>;
+  fetchFunction?: typeof fetch;
+  headers?: Record<string, string>;
 }
 
 export interface ProviderInfo {
@@ -26,82 +26,82 @@ export abstract class BaseClient {
 
   abstract banFromCommunity(
     payload: types.BanFromCommunity,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract blockCommunity(
     payload: { block: boolean; community_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ community_view: types.CommunityView }>;
 
   abstract blockInstance(
     payload: { block: boolean; instance_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract blockPerson(
     payload: { block: boolean; person_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ person_view: types.PersonView }>;
 
   abstract createComment(
     payload: types.CreateComment,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract createCommentReport(
     payload: { comment_id: number; reason: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract createPost(
     payload: types.CreatePost,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract createPostReport(
     payload: { post_id: number; reason: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract createPrivateMessage(
     payload: { content: string; recipient_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ private_message_view: types.PrivateMessageView }>;
 
   abstract createPrivateMessageReport(
     payload: { private_message_id: number; reason: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract deleteComment(
     payload: { comment_id: number; deleted: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract deleteImage(
     payload: { delete_token: string; url: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract deletePost(
     payload: { deleted: boolean; post_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract distinguishComment(
     payload: { comment_id: number; distinguished: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract editComment(
     payload: types.EditComment,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract editPost(
     payload: types.EditPost,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract featurePost(
@@ -110,26 +110,26 @@ export abstract class BaseClient {
       featured: boolean;
       post_id: number;
     },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract followCommunity(
     payload: { community_id: number; follow: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ community_view: types.CommunityView }>;
 
   abstract getCaptcha(
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.GetCaptchaResponse>;
 
   abstract getComments(
     payload: types.GetComments,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListCommentsResponse>;
 
   abstract getCommunity(
     payload: types.GetCommunity,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.GetCommunityResponse>;
 
   abstract getFederatedInstances(options?: RequestOptions): Promise<{
@@ -138,108 +138,108 @@ export abstract class BaseClient {
 
   abstract getModlog(
     payload: types.GetModlog,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListModlogResponse>;
 
   abstract getNotifications(
     payload: types.GetPersonMentions,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListNotificationsResponse>;
 
   abstract getPersonDetails(
     payload: { person_id: number } | { username: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.GetPersonDetailsResponse>;
 
   abstract getPersonMentions(
     payload: types.GetPersonMentions,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPersonMentionsResponse>;
 
   abstract getPost(
     payload: types.GetPost,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract getPosts(
     payload: types.GetPosts,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPostsResponse>;
 
   abstract getPrivateMessages(
     payload: types.GetPrivateMessages,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPrivateMessagesResponse>;
 
   abstract getRandomCommunity(
     payload: { type_: types.ListingType },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ community_view: types.CommunityView }>;
 
   abstract getReplies(
     payload: types.GetReplies,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListRepliesResponse>;
 
   abstract getSite(options?: RequestOptions): Promise<types.GetSiteResponse>;
 
   abstract getSiteMetadata(
     payload: { url: string },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.GetSiteMetadataResponse>;
 
   abstract getUnreadCount(
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.GetUnreadCountResponse>;
 
   abstract likeComment(
     payload: { comment_id: number; score: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract likePost(
     payload: { post_id: number; score: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract listCommentReports(
     payload: types.PageParams & { unresolved_only?: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListCommentReportsResponse>;
 
   abstract listCommunities(
     payload: types.ListCommunities,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListCommunitiesResponse>;
 
   abstract listPersonContent(
     payload: types.ListPersonContent,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPersonContentResponse>;
 
   abstract listPersonLiked(
     payload: types.PageParams & { type: types.LikeType },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPersonLikedResponse>;
 
   abstract listPersonSaved(
     payload: types.PageParams & { person_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPersonContentResponse>;
 
   abstract listPostReports(
     payload: types.PageParams & { unresolved_only?: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListPostReportsResponse>;
 
   abstract listReports(
     payload: types.ListReports,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListReportsResponse>;
 
   abstract lockPost(
     payload: { locked: boolean; post_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract login(
@@ -248,7 +248,7 @@ export abstract class BaseClient {
       totp_2fa_token?: string;
       username_or_email: string;
     },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ jwt?: string }>;
 
   abstract logout(options?: RequestOptions): Promise<void>;
@@ -257,78 +257,78 @@ export abstract class BaseClient {
 
   abstract markCommentReplyAsRead(
     payload: { comment_reply_id: number; read: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract markPersonMentionAsRead(
     payload: { person_mention_id: number; read: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract markPostAsRead(
     payload: { post_ids: number[]; read: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract markPrivateMessageAsRead(
     payload: { private_message_id: number; read: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract register(
     payload: types.Register,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.LoginResponse>;
 
   abstract removeComment(
     payload: { comment_id: number; reason?: string; removed: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract removePost(
     payload: { post_id: number; reason?: string; removed: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract resolveCommentReport(
     payload: { report_id: number; resolved: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract resolveObject(
     payload: {
       q: string;
     },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ResolveObjectResponse>;
 
   abstract resolvePostReport(
     payload: { report_id: number; resolved: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract saveComment(
     payload: { comment_id: number; save: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ comment_view: types.CommentView }>;
 
   abstract savePost(
     payload: { post_id: number; save: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: types.PostView }>;
 
   abstract saveUserSettings(
     payload: { show_nsfw: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<void>;
 
   abstract search(
     payload: types.Search,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.ListSearchResponse>;
 
   abstract uploadImage(
     payload: { file: File },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<types.UploadImageResponse>;
 }
diff --git a/src/providers/piefed/index.ts b/src/providers/piefed/index.ts
index 066a839..6e95f91 100644
--- a/src/providers/piefed/index.ts
+++ b/src/providers/piefed/index.ts
@@ -50,12 +50,12 @@ export class UnsafePiefedClient implements BaseClient {
   #url: string;
 
   constructor(url: string, options: BaseClientOptions) {
-    this.#customFetch = options.fetchFunction;
+    this.#customFetch = options.fetchFunction ?? globalThis.fetch;
     this.#url = url;
 
-    const headers = options.headers.Authorization
+    const headers = options.headers?.Authorization
       ? {
-          Authorization: options.headers.Authorization,
+          Authorization: options.headers?.Authorization,
         }
       : undefined;
 
@@ -73,7 +73,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async banFromCommunity(
     payload: Parameters<BaseClient["banFromCommunity"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["banFromCommunity"]> {
     await this.#client.POST("/community/moderate/ban", {
       ...options,
@@ -84,7 +84,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async blockCommunity(
     payload: Parameters<BaseClient["blockCommunity"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["blockCommunity"]> {
     const response = await this.#client.POST("/community/block", {
       ...options,
@@ -98,7 +98,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async blockInstance(
     payload: Parameters<BaseClient["blockInstance"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["blockInstance"]> {
     await this.#client.POST("/site/block", {
       ...options,
@@ -108,7 +108,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async blockPerson(
     payload: Parameters<BaseClient["blockPerson"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["blockPerson"]> {
     const response = await this.#client.POST("/user/block", {
       ...options,
@@ -123,7 +123,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async createComment(
     payload: Parameters<BaseClient["createComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["createComment"]> {
     const response = await this.#client.POST("/comment", {
       ...options,
@@ -140,7 +140,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async createCommentReport(
     payload: Parameters<BaseClient["createCommentReport"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["createCommentReport"]> {
     await this.#client.POST("/comment/report", {
       ...options,
@@ -150,7 +150,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async createPost(
     payload: Parameters<BaseClient["createPost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.POST("/post", {
       ...options,
@@ -167,7 +167,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async createPostReport(
     payload: Parameters<BaseClient["createPostReport"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["createPostReport"]> {
     await this.#client.POST("/post/report", {
       ...options,
@@ -177,7 +177,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async createPrivateMessage(
     payload: Parameters<BaseClient["createPrivateMessage"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["createPrivateMessage"]> {
     const response = await this.#client.POST("/private_message", {
       ...options,
@@ -186,7 +186,7 @@ export class UnsafePiefedClient implements BaseClient {
 
     return {
       private_message_view: compat.toPrivateMessageView(
-        response.data!.private_message_view,
+        response.data!.private_message_view
       ),
     };
   }
@@ -195,13 +195,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["createPrivateMessageReport"]>
   ): ReturnType<BaseClient["createPrivateMessageReport"]> {
     throw new UnsupportedError(
-      "Create private message report is not supported by piefed",
+      "Create private message report is not supported by piefed"
     );
   }
 
   async deleteComment(
     payload: Parameters<BaseClient["deleteComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["deleteComment"]> {
     const response = await this.#client.POST("/comment/delete", {
       ...options,
@@ -221,7 +221,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async deletePost(
     payload: { deleted: boolean; post_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: PostView }> {
     const response = await this.#client.POST("/post/delete", {
       ...options,
@@ -237,13 +237,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["distinguishComment"]>
   ): ReturnType<BaseClient["distinguishComment"]> {
     throw new UnsupportedError(
-      "Distinguish comment is not supported by piefed",
+      "Distinguish comment is not supported by piefed"
     );
   }
 
   async editComment(
     payload: Parameters<BaseClient["editComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["editComment"]> {
     const response = await this.#client.PUT("/comment", {
       ...options,
@@ -260,7 +260,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async editPost(
     payload: Parameters<BaseClient["editPost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.PUT("/post", {
       ...options,
@@ -277,7 +277,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async featurePost(
     payload: Parameters<BaseClient["featurePost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: PostView }> {
     const response = await this.#client.POST("/post/feature", {
       ...options,
@@ -291,7 +291,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async followCommunity(
     payload: Parameters<BaseClient["followCommunity"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["followCommunity"]> {
     const response = await this.#client.POST("/community/follow", {
       ...options,
@@ -311,15 +311,15 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getComments(
     payload: Parameters<BaseClient["getComments"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getComments"]> {
     if (payload.mode && payload.mode !== "piefed")
       throw new InvalidPayloadError(
-        `Connected to piefed, ${payload.mode} is not supported`,
+        `Connected to piefed, ${payload.mode} is not supported`
       );
 
     const query = cleanThreadiverseParams(
-      compat.fromPageParams(payload),
+      compat.fromPageParams(payload)
     ) satisfies components["schemas"]["GetComments"];
 
     const response = await this.#client.GET("/comment/list", {
@@ -336,7 +336,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getCommunity(
     payload: Parameters<BaseClient["getCommunity"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getCommunity"]> {
     const response = await this.#client.GET("/community", {
       ...options,
@@ -377,7 +377,7 @@ export class UnsafePiefedClient implements BaseClient {
     ].sort(
       (a, b) =>
         Date.parse(getInboxItemPublished(b)) -
-        Date.parse(getInboxItemPublished(a)),
+        Date.parse(getInboxItemPublished(a))
     );
 
     return {
@@ -388,7 +388,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getPersonDetails(
     payload: Parameters<BaseClient["getPersonDetails"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getPersonDetails"]> {
     const response = await this.#client.GET("/user", {
       ...options,
@@ -405,7 +405,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getPersonMentions(
     payload: Parameters<BaseClient["getPersonMentions"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getPersonMentions"]> {
     const response = await this.#client.GET("/user/mentions", {
       ...options,
@@ -421,7 +421,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getPost(
     payload: Parameters<BaseClient["getPost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const query = payload satisfies components["schemas"]["GetPost"];
 
@@ -438,15 +438,15 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getPosts(
     payload: Parameters<BaseClient["getPosts"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getPosts"]> {
     if (payload.mode && payload.mode !== "piefed")
       throw new InvalidPayloadError(
-        `Connected to piefed, ${payload.mode} is not supported`,
+        `Connected to piefed, ${payload.mode} is not supported`
       );
 
     const query = cleanThreadiverseParams(
-      compat.fromPageParams(payload),
+      compat.fromPageParams(payload)
     ) satisfies components["schemas"]["GetPosts"];
 
     const response = await this.#client.GET("/post/list", {
@@ -463,7 +463,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async getPrivateMessages(
     payload: Parameters<BaseClient["getPrivateMessages"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getPrivateMessages"]> {
     const response = await this.#client.GET("/private_message/list", {
       ...options,
@@ -481,13 +481,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["getRandomCommunity"]>
   ): ReturnType<BaseClient["getRandomCommunity"]> {
     throw new UnsupportedError(
-      "Get random community is not supported by piefed",
+      "Get random community is not supported by piefed"
     );
   }
 
   async getReplies(
     payload: Parameters<BaseClient["getReplies"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["getReplies"]> {
     const response = await this.#client.GET("/user/replies", {
       ...options,
@@ -512,14 +512,14 @@ export class UnsafePiefedClient implements BaseClient {
         ? {
             ...response.data!.my_user,
             community_blocks: response.data!.my_user?.community_blocks.map(
-              ({ community }) => compat.toCommunity(community),
+              ({ community }) => compat.toCommunity(community)
             ),
             follows: response.data!.my_user.follows.map((f) => ({
               community: compat.toCommunity(f.community),
               follower: compat.toPerson(f.follower),
             })),
             instance_blocks: response.data!.my_user?.instance_blocks.map(
-              ({ instance }) => instance,
+              ({ instance }) => instance
             ),
             local_user_view: {
               ...response.data!.my_user.local_user_view,
@@ -529,14 +529,14 @@ export class UnsafePiefedClient implements BaseClient {
                   response.data!.my_user.local_user_view.local_user.show_nsfw,
               },
               person: compat.toPerson(
-                response.data!.my_user.local_user_view.person,
+                response.data!.my_user.local_user_view.person
               ),
             },
             moderates: response.data!.my_user.moderates.map(
-              compat.toCommunityModeratorView,
+              compat.toCommunityModeratorView
             ),
             person_blocks: response.data!.my_user?.person_blocks.map(
-              ({ target }) => compat.toPerson(target),
+              ({ target }) => compat.toPerson(target)
             ),
           }
         : undefined,
@@ -563,7 +563,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async likeComment(
     payload: Parameters<BaseClient["likeComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["likeComment"]> {
     const response = await this.#client.POST("/comment/like", {
       ...options,
@@ -579,7 +579,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async likePost(
     payload: Parameters<BaseClient["likePost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.POST("/post/like", {
       ...options,
@@ -597,13 +597,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["listCommentReports"]>
   ): ReturnType<BaseClient["listCommentReports"]> {
     throw new UnsupportedError(
-      "List comment reports is not supported by piefed",
+      "List comment reports is not supported by piefed"
     );
   }
 
   async listCommunities(
     payload: Parameters<BaseClient["listCommunities"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["listCommunities"]> {
     const response = await this.#client.GET("/community/list", {
       ...options,
@@ -619,7 +619,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async listPersonContent(
     payload: ListPersonContent,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<ListPersonContentResponse> {
     switch (payload.type) {
       case "All":
@@ -632,8 +632,8 @@ export class UnsafePiefedClient implements BaseClient {
           [...posts.data, ...comments.data].sort(
             (a, b) =>
               getPostCommentItemCreatedDate(b) -
-              getPostCommentItemCreatedDate(a),
-          ),
+              getPostCommentItemCreatedDate(a)
+          )
         );
 
         return {
@@ -659,7 +659,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async listPersonSaved(
     payload: Parameters<BaseClient["listPersonContent"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["listPersonContent"]> {
     const response = await this.#client.GET("/user", {
       ...options,
@@ -679,7 +679,7 @@ export class UnsafePiefedClient implements BaseClient {
           ].sort(
             (a, b) =>
               getPostCommentItemCreatedDate(b) -
-              getPostCommentItemCreatedDate(a),
+              getPostCommentItemCreatedDate(a)
           );
         case "Comments":
           return response.data!.comments.map(compat.toCommentView);
@@ -708,7 +708,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async lockPost(
     payload: { locked: boolean; post_id: number },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: PostView }> {
     const response = await this.#client.POST("/post/lock", {
       ...options,
@@ -722,7 +722,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async login(
     payload: Parameters<BaseClient["login"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.POST("/user/login", {
       ...options,
@@ -741,7 +741,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async markCommentReplyAsRead(
     payload: Parameters<BaseClient["markCommentReplyAsRead"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["markCommentReplyAsRead"]> {
     await this.#client.POST("/comment/mark_as_read", {
       ...options,
@@ -751,7 +751,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async markPersonMentionAsRead(
     payload: Parameters<BaseClient["markPersonMentionAsRead"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["markPersonMentionAsRead"]> {
     await this.#client.POST("/comment/mark_as_read", {
       ...options,
@@ -764,7 +764,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async markPostAsRead(
     payload: Parameters<BaseClient["markPostAsRead"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["markPostAsRead"]> {
     await this.#client.POST("/post/mark_as_read", {
       ...options,
@@ -774,7 +774,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async markPrivateMessageAsRead(
     payload: Parameters<BaseClient["markPrivateMessageAsRead"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["markPrivateMessageAsRead"]> {
     await this.#client.POST("/private_message/mark_as_read", {
       ...options,
@@ -790,7 +790,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async removeComment(
     payload: Parameters<BaseClient["removeComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["removeComment"]> {
     const response = await this.#client.POST("/comment/remove", {
       ...options,
@@ -804,7 +804,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async removePost(
     payload: { post_id: number; removed: boolean },
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<{ post_view: PostView }> {
     const response = await this.#client.POST("/post/remove", {
       ...options,
@@ -820,13 +820,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["resolveCommentReport"]>
   ): ReturnType<BaseClient["resolveCommentReport"]> {
     throw new UnsupportedError(
-      "Resolve comment report is not supported by piefed",
+      "Resolve comment report is not supported by piefed"
     );
   }
 
   async resolveObject(
     payload: Parameters<BaseClient["resolveObject"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["resolveObject"]> {
     const response = await this.#client.GET("/resolve_object", {
       ...options,
@@ -858,13 +858,13 @@ export class UnsafePiefedClient implements BaseClient {
     ..._params: Parameters<BaseClient["resolvePostReport"]>
   ): ReturnType<BaseClient["resolvePostReport"]> {
     throw new UnsupportedError(
-      "Resolve post report is not supported by piefed",
+      "Resolve post report is not supported by piefed"
     );
   }
 
   async saveComment(
     payload: Parameters<BaseClient["saveComment"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["saveComment"]> {
     const response = await this.#client.PUT("/comment/save", {
       ...options,
@@ -878,7 +878,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async savePost(
     payload: Parameters<BaseClient["savePost"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["savePost"]> {
     const response = await this.#client.PUT("/post/save", {
       ...options,
@@ -898,7 +898,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async search(
     payload: Parameters<BaseClient["search"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ): ReturnType<BaseClient["search"]> {
     if (payload.type_ === "Comments") {
       throw new UnsupportedError("Comment search is not supported by piefed");
@@ -922,7 +922,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async uploadImage(
     payload: Parameters<BaseClient["uploadImage"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const formData = new FormData();
     formData.append("file", payload.file);
@@ -940,7 +940,7 @@ export class UnsafePiefedClient implements BaseClient {
         body: formData,
         headers: this.#headers,
         method: "POST",
-      },
+      }
     );
 
     await validateResponse(response);
@@ -954,7 +954,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async #listPersonComments(
     payload: Parameters<BaseClient["listPersonContent"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.GET("/comment/list", {
       ...options,
@@ -970,7 +970,7 @@ export class UnsafePiefedClient implements BaseClient {
 
   async #listPersonPosts(
     payload: Parameters<BaseClient["listPersonContent"]>[0],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     const response = await this.#client.GET("/post/list", {
       ...options,