refactor: 🏷️ Update tsconfig.json and fix resulting errors

packages/sdk/entities/collection.ts

@@ -7,21 +7,23 @@ import type { JSONObject } from "../types.ts";
 import { Entity } from "./entity.ts";
 
 export class Collection extends Entity {
-    public constructor(public data: z.infer<typeof CollectionSchema>) {
+    public constructor(public override data: z.infer<typeof CollectionSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Collection> {
+    public static override fromJSON(json: JSONObject): Promise<Collection> {
         return CollectionSchema.parseAsync(json).then((u) => new Collection(u));
     }
 }
 
 export class URICollection extends Entity {
-    public constructor(public data: z.infer<typeof URICollectionSchema>) {
+    public constructor(
+        public override data: z.infer<typeof URICollectionSchema>,
+    ) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<URICollection> {
+    public static override fromJSON(json: JSONObject): Promise<URICollection> {
         return URICollectionSchema.parseAsync(json).then(
             (u) => new URICollection(u),
         );

packages/sdk/entities/contentformat.ts

@@ -20,63 +20,81 @@ export class ContentFormat {
 }
 
 export class TextContentFormat extends ContentFormat {
-    public static fromJSON(data: JSONObject): Promise<TextContentFormat> {
+    public static override fromJSON(
+        data: JSONObject,
+    ): Promise<TextContentFormat> {
         return TextContentFormatSchema.parseAsync(data).then(
             (d) => new TextContentFormat(d),
         );
     }
 
-    public constructor(public data: z.infer<typeof TextContentFormatSchema>) {
+    public constructor(
+        public override data: z.infer<typeof TextContentFormatSchema>,
+    ) {
         super(data);
     }
 }
 
 export class NonTextContentFormat extends ContentFormat {
-    public static fromJSON(data: JSONObject): Promise<NonTextContentFormat> {
+    public static override fromJSON(
+        data: JSONObject,
+    ): Promise<NonTextContentFormat> {
         return NonTextContentFormatSchema.parseAsync(data).then(
             (d) => new NonTextContentFormat(d),
         );
     }
 
     public constructor(
-        public data: z.infer<typeof NonTextContentFormatSchema>,
+        public override data: z.infer<typeof NonTextContentFormatSchema>,
     ) {
         super(data);
     }
 }
 
 export class ImageContentFormat extends ContentFormat {
-    public static fromJSON(data: JSONObject): Promise<ImageContentFormat> {
+    public static override fromJSON(
+        data: JSONObject,
+    ): Promise<ImageContentFormat> {
         return ImageContentFormatSchema.parseAsync(data).then(
             (d) => new ImageContentFormat(d),
         );
     }
 
-    public constructor(public data: z.infer<typeof ImageContentFormatSchema>) {
+    public constructor(
+        public override data: z.infer<typeof ImageContentFormatSchema>,
+    ) {
         super(data);
     }
 }
 
 export class VideoContentFormat extends ContentFormat {
-    public static fromJSON(data: JSONObject): Promise<VideoContentFormat> {
+    public static override fromJSON(
+        data: JSONObject,
+    ): Promise<VideoContentFormat> {
         return VideoContentFormatSchema.parseAsync(data).then(
             (d) => new VideoContentFormat(d),
         );
     }
 
-    public constructor(public data: z.infer<typeof VideoContentFormatSchema>) {
+    public constructor(
+        public override data: z.infer<typeof VideoContentFormatSchema>,
+    ) {
         super(data);
     }
 }
 
 export class AudioContentFormat extends ContentFormat {
-    public static fromJSON(data: JSONObject): Promise<AudioContentFormat> {
+    public static override fromJSON(
+        data: JSONObject,
+    ): Promise<AudioContentFormat> {
         return AudioContentFormatSchema.parseAsync(data).then(
             (d) => new AudioContentFormat(d),
         );
     }
 
-    public constructor(public data: z.infer<typeof AudioContentFormatSchema>) {
+    public constructor(
+        public override data: z.infer<typeof AudioContentFormatSchema>,
+    ) {
         super(data);
     }
 }

packages/sdk/entities/delete.ts

@@ -4,13 +4,13 @@ import type { JSONObject } from "../types.ts";
 import { Entity } from "./entity.ts";
 
 export class Delete extends Entity {
-    public static name = "Delete";
+    public static override name = "Delete";
 
-    public constructor(public data: z.infer<typeof DeleteSchema>) {
+    public constructor(public override data: z.infer<typeof DeleteSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Delete> {
+    public static override fromJSON(json: JSONObject): Promise<Delete> {
         return DeleteSchema.parseAsync(json).then((u) => new Delete(u));
     }
 }

packages/sdk/entities/extensions/likes.ts

@@ -4,25 +4,25 @@ import type { JSONObject } from "../../types.ts";
 import { Entity } from "../entity.ts";
 
 export class Like extends Entity {
-    public static name = "pub.versia:likes/Like";
+    public static override name = "pub.versia:likes/Like";
 
-    public constructor(public data: z.infer<typeof LikeSchema>) {
+    public constructor(public override data: z.infer<typeof LikeSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Like> {
+    public static override fromJSON(json: JSONObject): Promise<Like> {
         return LikeSchema.parseAsync(json).then((u) => new Like(u));
     }
 }
 
 export class Dislike extends Entity {
-    public static name = "pub.versia:likes/Dislike";
+    public static override name = "pub.versia:likes/Dislike";
 
-    public constructor(public data: z.infer<typeof DislikeSchema>) {
+    public constructor(public override data: z.infer<typeof DislikeSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Dislike> {
+    public static override fromJSON(json: JSONObject): Promise<Dislike> {
         return DislikeSchema.parseAsync(json).then((u) => new Dislike(u));
     }
 }

packages/sdk/entities/extensions/polls.ts

@@ -4,13 +4,13 @@ import type { JSONObject } from "../../types.ts";
 import { Entity } from "../entity.ts";
 
 export class Vote extends Entity {
-    public static name = "pub.versia:polls/Vote";
+    public static override name = "pub.versia:polls/Vote";
 
-    public constructor(public data: z.infer<typeof VoteSchema>) {
+    public constructor(public override data: z.infer<typeof VoteSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Vote> {
+    public static override fromJSON(json: JSONObject): Promise<Vote> {
         return VoteSchema.parseAsync(json).then((u) => new Vote(u));
     }
 }

packages/sdk/entities/extensions/reactions.ts

@@ -4,13 +4,13 @@ import type { JSONObject } from "../../types.ts";
 import { Entity } from "../entity.ts";
 
 export class Reaction extends Entity {
-    public static name = "pub.versia:reactions/Reaction";
+    public static override name = "pub.versia:reactions/Reaction";
 
-    public constructor(public data: z.infer<typeof ReactionSchema>) {
+    public constructor(public override data: z.infer<typeof ReactionSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Reaction> {
+    public static override fromJSON(json: JSONObject): Promise<Reaction> {
         return ReactionSchema.parseAsync(json).then((u) => new Reaction(u));
     }
 }

packages/sdk/entities/extensions/reports.ts

@@ -4,13 +4,13 @@ import type { JSONObject } from "../../types.ts";
 import { Entity } from "../entity.ts";
 
 export class Report extends Entity {
-    public static name = "pub.versia:reports/Report";
+    public static override name = "pub.versia:reports/Report";
 
-    public constructor(public data: z.infer<typeof ReportSchema>) {
+    public constructor(public override data: z.infer<typeof ReportSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Report> {
+    public static override fromJSON(json: JSONObject): Promise<Report> {
         return ReportSchema.parseAsync(json).then((u) => new Report(u));
     }
 }

packages/sdk/entities/extensions/share.ts

@@ -4,13 +4,13 @@ import type { JSONObject } from "../../types.ts";
 import { Entity } from "../entity.ts";
 
 export class Share extends Entity {
-    public static name = "pub.versia:share/Share";
+    public static override name = "pub.versia:share/Share";
 
-    public constructor(public data: z.infer<typeof ShareSchema>) {
+    public constructor(public override data: z.infer<typeof ShareSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Share> {
+    public static override fromJSON(json: JSONObject): Promise<Share> {
         return ShareSchema.parseAsync(json).then((u) => new Share(u));
     }
 }

packages/sdk/entities/follow.ts

@@ -9,25 +9,27 @@ import type { JSONObject } from "../types.ts";
 import { Entity } from "./entity.ts";
 
 export class Follow extends Entity {
-    public static name = "Follow";
+    public static override name = "Follow";
 
-    public constructor(public data: z.infer<typeof FollowSchema>) {
+    public constructor(public override data: z.infer<typeof FollowSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Follow> {
+    public static override fromJSON(json: JSONObject): Promise<Follow> {
         return FollowSchema.parseAsync(json).then((u) => new Follow(u));
     }
 }
 
 export class FollowAccept extends Entity {
-    public static name = "FollowAccept";
+    public static override name = "FollowAccept";
 
-    public constructor(public data: z.infer<typeof FollowAcceptSchema>) {
+    public constructor(
+        public override data: z.infer<typeof FollowAcceptSchema>,
+    ) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<FollowAccept> {
+    public static override fromJSON(json: JSONObject): Promise<FollowAccept> {
         return FollowAcceptSchema.parseAsync(json).then(
             (u) => new FollowAccept(u),
         );
@@ -35,13 +37,15 @@ export class FollowAccept extends Entity {
 }
 
 export class FollowReject extends Entity {
-    public static name = "FollowReject";
+    public static override name = "FollowReject";
 
-    public constructor(public data: z.infer<typeof FollowRejectSchema>) {
+    public constructor(
+        public override data: z.infer<typeof FollowRejectSchema>,
+    ) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<FollowReject> {
+    public static override fromJSON(json: JSONObject): Promise<FollowReject> {
         return FollowRejectSchema.parseAsync(json).then(
             (u) => new FollowReject(u),
         );
@@ -49,13 +53,13 @@ export class FollowReject extends Entity {
 }
 
 export class Unfollow extends Entity {
-    public static name = "Unfollow";
+    public static override name = "Unfollow";
 
-    public constructor(public data: z.infer<typeof UnfollowSchema>) {
+    public constructor(public override data: z.infer<typeof UnfollowSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Unfollow> {
+    public static override fromJSON(json: JSONObject): Promise<Unfollow> {
         return UnfollowSchema.parseAsync(json).then((u) => new Unfollow(u));
     }
 }

packages/sdk/entities/instancemetadata.ts

@@ -5,9 +5,11 @@ import { ImageContentFormat } from "./contentformat.ts";
 import { Entity } from "./entity.ts";
 
 export class InstanceMetadata extends Entity {
-    public static name = "InstanceMetadata";
+    public static override name = "InstanceMetadata";
 
-    public constructor(public data: z.infer<typeof InstanceMetadataSchema>) {
+    public constructor(
+        public override data: z.infer<typeof InstanceMetadataSchema>,
+    ) {
         super(data);
     }
 
@@ -23,7 +25,9 @@ export class InstanceMetadata extends Entity {
             : undefined;
     }
 
-    public static fromJSON(json: JSONObject): Promise<InstanceMetadata> {
+    public static override fromJSON(
+        json: JSONObject,
+    ): Promise<InstanceMetadata> {
         return InstanceMetadataSchema.parseAsync(json).then(
             (u) => new InstanceMetadata(u),
         );

packages/sdk/entities/note.ts

@@ -5,13 +5,13 @@ import { NonTextContentFormat, TextContentFormat } from "./contentformat.ts";
 import { Entity } from "./entity.ts";
 
 export class Note extends Entity {
-    public static name = "Note";
+    public static override name = "Note";
 
-    public constructor(public data: z.infer<typeof NoteSchema>) {
+    public constructor(public override data: z.infer<typeof NoteSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<Note> {
+    public static override fromJSON(json: JSONObject): Promise<Note> {
         return NoteSchema.parseAsync(json).then((n) => new Note(n));
     }
 

packages/sdk/entities/user.ts

@@ -5,13 +5,13 @@ import { ImageContentFormat, TextContentFormat } from "./contentformat.ts";
 import { Entity } from "./entity.ts";
 
 export class User extends Entity {
-    public static name = "User";
+    public static override name = "User";
 
-    public constructor(public data: z.infer<typeof UserSchema>) {
+    public constructor(public override data: z.infer<typeof UserSchema>) {
         super(data);
     }
 
-    public static fromJSON(json: JSONObject): Promise<User> {
+    public static override fromJSON(json: JSONObject): Promise<User> {
         return UserSchema.parseAsync(json).then((u) => new User(u));
     }