chore: 🎨 format

packages/megalodon/package.json

@@ -5,7 +5,8 @@
   "typings": "./lib/src/index.d.ts",
   "scripts": {
     "build": "tsc -p ./",
-    "lint": "eslint --ext .js,.ts src",
+    "lint": "pnpm rome check --apply src/**/*.ts",
+		"format": "pnpm rome format --write src/**/*.ts",
     "doc": "typedoc --out ../docs ./src",
     "test": "NODE_ENV=test jest -u --maxWorkers=3"
   },

packages/megalodon/src/entities/account.ts

@@ -3,25 +3,25 @@
 /// <reference path="field.ts" />
 namespace Entity {
 	export type Account = {
-    id: string
-    username: string
-    acct: string
-    display_name: string
-    locked: boolean
-    created_at: string
-    followers_count: number
-    following_count: number
-    statuses_count: number
-    note: string
-    url: string
-    avatar: string
-    avatar_static: string
-    header: string
-    header_static: string
-    emojis: Array<Emoji>
-    moved: Account | null
-    fields: Array<Field>
-    bot: boolean | null
-    source?: Source
-  }
+		id: string;
+		username: string;
+		acct: string;
+		display_name: string;
+		locked: boolean;
+		created_at: string;
+		followers_count: number;
+		following_count: number;
+		statuses_count: number;
+		note: string;
+		url: string;
+		avatar: string;
+		avatar_static: string;
+		header: string;
+		header_static: string;
+		emojis: Array<Emoji>;
+		moved: Account | null;
+		fields: Array<Field>;
+		bot: boolean | null;
+		source?: Source;
+	};
 }

packages/megalodon/src/entities/activity.ts

@@ -1,8 +1,8 @@
 namespace Entity {
 	export type Activity = {
-    week: string
-    statuses: string
-    logins: string
-    registrations: string
-  }
+		week: string;
+		statuses: string;
+		logins: string;
+		registrations: string;
+	};
 }

packages/megalodon/src/entities/announcement.ts

@@ -4,31 +4,31 @@
 
 namespace Entity {
 	export type Announcement = {
-    id: string
-    content: string
-    starts_at: string | null
-    ends_at: string | null
-    published: boolean
-    all_day: boolean
-    published_at: string
-    updated_at: string
-    read?: boolean
-    mentions: Array<AnnouncementAccount>
-    statuses: Array<AnnouncementStatus>
-    tags: Array<Tag>
-    emojis: Array<Emoji>
-    reactions: Array<Reaction>
-  }
+		id: string;
+		content: string;
+		starts_at: string | null;
+		ends_at: string | null;
+		published: boolean;
+		all_day: boolean;
+		published_at: string;
+		updated_at: string;
+		read?: boolean;
+		mentions: Array<AnnouncementAccount>;
+		statuses: Array<AnnouncementStatus>;
+		tags: Array<Tag>;
+		emojis: Array<Emoji>;
+		reactions: Array<Reaction>;
+	};
 
 	export type AnnouncementAccount = {
-    id: string
-    username: string
-    url: string
-    acct: string
-  }
+		id: string;
+		username: string;
+		url: string;
+		acct: string;
+	};
 
 	export type AnnouncementStatus = {
-    id: string
-    url: string
-  }
+		id: string;
+		url: string;
+	};
 }

packages/megalodon/src/entities/application.ts

@@ -1,7 +1,7 @@
 namespace Entity {
 	export type Application = {
-    name: string
-    website?: string | null
-    vapid_key?: string | null
-  }
+		name: string;
+		website?: string | null;
+		vapid_key?: string | null;
+	};
 }

packages/megalodon/src/entities/async_attachment.ts

@@ -1,14 +1,14 @@
 /// <reference path="attachment.ts" />
 namespace Entity {
 	export type AsyncAttachment = {
-    id: string
-    type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
-    url: string | null
-    remote_url: string | null
-    preview_url: string
-    text_url: string | null
-    meta: Meta | null
-    description: string | null
-    blurhash: string | null
-  }
+		id: string;
+		type: "unknown" | "image" | "gifv" | "video" | "audio";
+		url: string | null;
+		remote_url: string | null;
+		preview_url: string;
+		text_url: string | null;
+		meta: Meta | null;
+		description: string | null;
+		blurhash: string | null;
+	};
 }

packages/megalodon/src/entities/attachment.ts

@@ -1,49 +1,49 @@
 namespace Entity {
 	export type Sub = {
 		// For Image, Gifv, and Video
-    width?: number
-    height?: number
-    size?: string
-    aspect?: number
+		width?: number;
+		height?: number;
+		size?: string;
+		aspect?: number;
 
 		// For Gifv and Video
-    frame_rate?: string
+		frame_rate?: string;
 
 		// For Audio, Gifv, and Video
-    duration?: number
-    bitrate?: number
-  }
+		duration?: number;
+		bitrate?: number;
+	};
 
 	export type Focus = {
-    x: number
-    y: number
-  }
+		x: number;
+		y: number;
+	};
 
 	export type Meta = {
-    original?: Sub
-    small?: Sub
-    focus?: Focus
-    length?: string
-    duration?: number
-    fps?: number
-    size?: string
-    width?: number
-    height?: number
-    aspect?: number
-    audio_encode?: string
-    audio_bitrate?: string
-    audio_channel?: string
-  }
+		original?: Sub;
+		small?: Sub;
+		focus?: Focus;
+		length?: string;
+		duration?: number;
+		fps?: number;
+		size?: string;
+		width?: number;
+		height?: number;
+		aspect?: number;
+		audio_encode?: string;
+		audio_bitrate?: string;
+		audio_channel?: string;
+	};
 
 	export type Attachment = {
-    id: string
-    type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
-    url: string
-    remote_url: string | null
-    preview_url: string | null
-    text_url: string | null
-    meta: Meta | null
-    description: string | null
-    blurhash: string | null
-  }
+		id: string;
+		type: "unknown" | "image" | "gifv" | "video" | "audio";
+		url: string;
+		remote_url: string | null;
+		preview_url: string | null;
+		text_url: string | null;
+		meta: Meta | null;
+		description: string | null;
+		blurhash: string | null;
+	};
 }

packages/megalodon/src/entities/card.ts

@@ -1,16 +1,16 @@
 namespace Entity {
 	export type Card = {
-    url: string
-    title: string
-    description: string
-    type: 'link' | 'photo' | 'video' | 'rich'
-    image?: string
-    author_name?: string
-    author_url?: string
-    provider_name?: string
-    provider_url?: string
-    html?: string
-    width?: number
-    height?: number
-  }
+		url: string;
+		title: string;
+		description: string;
+		type: "link" | "photo" | "video" | "rich";
+		image?: string;
+		author_name?: string;
+		author_url?: string;
+		provider_name?: string;
+		provider_url?: string;
+		html?: string;
+		width?: number;
+		height?: number;
+	};
 }

packages/megalodon/src/entities/context.ts

@@ -2,7 +2,7 @@
 
 namespace Entity {
 	export type Context = {
-    ancestors: Array<Status>
-    descendants: Array<Status>
-  }
+		ancestors: Array<Status>;
+		descendants: Array<Status>;
+	};
 }

packages/megalodon/src/entities/conversation.ts

@@ -3,9 +3,9 @@
 
 namespace Entity {
 	export type Conversation = {
-    id: string
-    accounts: Array<Account>
-    last_status: Status | null
-    unread: boolean
-  }
+		id: string;
+		accounts: Array<Account>;
+		last_status: Status | null;
+		unread: boolean;
+	};
 }

packages/megalodon/src/entities/emoji.ts

@@ -1,9 +1,9 @@
 namespace Entity {
 	export type Emoji = {
-    shortcode: string
-    static_url: string
-    url: string
-    visible_in_picker: boolean
-    category: string
-  }
+		shortcode: string;
+		static_url: string;
+		url: string;
+		visible_in_picker: boolean;
+		category: string;
+	};
 }

packages/megalodon/src/entities/featured_tag.ts

@@ -1,8 +1,8 @@
 namespace Entity {
 	export type FeaturedTag = {
-    id: string
-    name: string
-    statuses_count: number
-    last_status_at: string
-  }
+		id: string;
+		name: string;
+		statuses_count: number;
+		last_status_at: string;
+	};
 }

packages/megalodon/src/entities/field.ts

@@ -1,7 +1,7 @@
 namespace Entity {
 	export type Field = {
-    name: string
-    value: string
-    verified_at: string | null
-  }
+		name: string;
+		value: string;
+		verified_at: string | null;
+	};
 }

packages/megalodon/src/entities/filter.ts

@@ -1,12 +1,12 @@
 namespace Entity {
 	export type Filter = {
-    id: string
-    phrase: string
-    context: Array<FilterContext>
-    expires_at: string | null
-    irreversible: boolean
-    whole_word: boolean
-  }
+		id: string;
+		phrase: string;
+		context: Array<FilterContext>;
+		expires_at: string | null;
+		irreversible: boolean;
+		whole_word: boolean;
+	};
 
-  export type FilterContext = string
+	export type FilterContext = string;
 }

packages/megalodon/src/entities/history.ts

@@ -1,7 +1,7 @@
 namespace Entity {
 	export type History = {
-    day: string
-    uses: number
-    accounts: number
-  }
+		day: string;
+		uses: number;
+		accounts: number;
+	};
 }

packages/megalodon/src/entities/identity_proof.ts

@@ -1,9 +1,9 @@
 namespace Entity {
 	export type IdentityProof = {
-    provider: string
-    provider_username: string
-    updated_at: string
-    proof_url: string
-    profile_url: string
-  }
+		provider: string;
+		provider_username: string;
+		updated_at: string;
+		proof_url: string;
+		profile_url: string;
+	};
 }

packages/megalodon/src/entities/instance.ts

@@ -4,38 +4,38 @@
 
 namespace Entity {
 	export type Instance = {
-    uri: string
-    title: string
-    description: string
-    email: string
-    version: string
-    thumbnail: string | null
-    urls: URLs
-    stats: Stats
-    languages: Array<string>
-    contact_account: Account | null
-    max_toot_chars?: number
-    registrations?: boolean
+		uri: string;
+		title: string;
+		description: string;
+		email: string;
+		version: string;
+		thumbnail: string | null;
+		urls: URLs;
+		stats: Stats;
+		languages: Array<string>;
+		contact_account: Account | null;
+		max_toot_chars?: number;
+		registrations?: boolean;
 		configuration?: {
 			statuses: {
-        max_characters: number
-        max_media_attachments: number
-        characters_reserved_per_url: number
-      }
+				max_characters: number;
+				max_media_attachments: number;
+				characters_reserved_per_url: number;
+			};
 			media_attachments: {
-        supported_mime_types: Array<string>
-        image_size_limit: number
-        image_matrix_limit: number
-        video_size_limit: number
-        video_frame_limit: number
-        video_matrix_limit: number
-      }
+				supported_mime_types: Array<string>;
+				image_size_limit: number;
+				image_matrix_limit: number;
+				video_size_limit: number;
+				video_frame_limit: number;
+				video_matrix_limit: number;
+			};
 			polls: {
-        max_options: number
-        max_characters_per_option: number
-        min_expiration: number
-        max_expiration: number
-      }
-    }
-  }
+				max_options: number;
+				max_characters_per_option: number;
+				min_expiration: number;
+				max_expiration: number;
+			};
+		};
+	};
 }

packages/megalodon/src/entities/list.ts

@@ -1,6 +1,6 @@
 namespace Entity {
 	export type List = {
-    id: string
-    title: string
-  }
+		id: string;
+		title: string;
+	};
 }

packages/megalodon/src/entities/marker.ts

@@ -1,15 +1,15 @@
 namespace Entity {
 	export type Marker = {
 		home?: {
-      last_read_id: string
-      version: number
-      updated_at: string
-    }
+			last_read_id: string;
+			version: number;
+			updated_at: string;
+		};
 		notifications?: {
-      last_read_id: string
-      version: number
-      updated_at: string
-      unread_count?: number
-    }
-  }
+			last_read_id: string;
+			version: number;
+			updated_at: string;
+			unread_count?: number;
+		};
+	};
 }

packages/megalodon/src/entities/mention.ts

@@ -1,8 +1,8 @@
 namespace Entity {
 	export type Mention = {
-    id: string
-    username: string
-    url: string
-    acct: string
-  }
+		id: string;
+		username: string;
+		url: string;
+		acct: string;
+	};
 }

packages/megalodon/src/entities/notification.ts

@@ -3,13 +3,13 @@
 
 namespace Entity {
 	export type Notification = {
-    account: Account
-    created_at: string
-    id: string
-    status?: Status
-    emoji?: string
-    type: NotificationType
-  }
+		account: Account;
+		created_at: string;
+		id: string;
+		status?: Status;
+		emoji?: string;
+		type: NotificationType;
+	};
 
-  export type NotificationType = string
+	export type NotificationType = string;
 }

packages/megalodon/src/entities/poll.ts

@@ -2,13 +2,13 @@
 
 namespace Entity {
 	export type Poll = {
-    id: string
-    expires_at: string | null
-    expired: boolean
-    multiple: boolean
-    votes_count: number
-    options: Array<PollOption>
-    voted: boolean
-		own_votes: Array<number>
-  }
+		id: string;
+		expires_at: string | null;
+		expired: boolean;
+		multiple: boolean;
+		votes_count: number;
+		options: Array<PollOption>;
+		voted: boolean;
+		own_votes: Array<number>;
+	};
 }

packages/megalodon/src/entities/poll_option.ts

@@ -1,6 +1,6 @@
 namespace Entity {
 	export type PollOption = {
-    title: string
-    votes_count: number | null
-  }
+		title: string;
+		votes_count: number | null;
+	};
 }

packages/megalodon/src/entities/preferences.ts

@@ -1,9 +1,9 @@
 namespace Entity {
 	export type Preferences = {
-    'posting:default:visibility': 'public' | 'unlisted' | 'private' | 'direct'
-    'posting:default:sensitive': boolean
-    'posting:default:language': string | null
-    'reading:expand:media': 'default' | 'show_all' | 'hide_all'
-    'reading:expand:spoilers': boolean
-  }
+		"posting:default:visibility": "public" | "unlisted" | "private" | "direct";
+		"posting:default:sensitive": boolean;
+		"posting:default:language": string | null;
+		"reading:expand:media": "default" | "show_all" | "hide_all";
+		"reading:expand:spoilers": boolean;
+	};
 }

packages/megalodon/src/entities/push_subscription.ts

@@ -1,16 +1,16 @@
 namespace Entity {
 	export type Alerts = {
-    follow: boolean
-    favourite: boolean
-    mention: boolean
-    reblog: boolean
-    poll: boolean
-  }
+		follow: boolean;
+		favourite: boolean;
+		mention: boolean;
+		reblog: boolean;
+		poll: boolean;
+	};
 
 	export type PushSubscription = {
-    id: string
-    endpoint: string
-    server_key: string
-    alerts: Alerts
-  }
+		id: string;
+		endpoint: string;
+		server_key: string;
+		alerts: Alerts;
+	};
 }

packages/megalodon/src/entities/reaction.ts

@@ -2,10 +2,10 @@
 
 namespace Entity {
 	export type Reaction = {
-    count: number
-    me: boolean
-    name: string
-    url?: string
-    accounts?: Array<Account>
-  }
+		count: number;
+		me: boolean;
+		name: string;
+		url?: string;
+		accounts?: Array<Account>;
+	};
 }

packages/megalodon/src/entities/relationship.ts

@@ -1,17 +1,17 @@
 namespace Entity {
 	export type Relationship = {
-    id: string
-    following: boolean
-    followed_by: boolean
-    delivery_following?: boolean
-    blocking: boolean
-    blocked_by: boolean
-    muting: boolean
-    muting_notifications: boolean
-    requested: boolean
-    domain_blocking: boolean
-    showing_reblogs: boolean
-    endorsed: boolean
-    notifying: boolean
-  }
+		id: string;
+		following: boolean;
+		followed_by: boolean;
+		delivery_following?: boolean;
+		blocking: boolean;
+		blocked_by: boolean;
+		muting: boolean;
+		muting_notifications: boolean;
+		requested: boolean;
+		domain_blocking: boolean;
+		showing_reblogs: boolean;
+		endorsed: boolean;
+		notifying: boolean;
+	};
 }

packages/megalodon/src/entities/report.ts

@@ -1,9 +1,9 @@
 namespace Entity {
 	export type Report = {
-    id: string
-    action_taken: string
-    comment: string
-    account_id: string
-    status_ids: Array<string>
-  }
+		id: string;
+		action_taken: string;
+		comment: string;
+		account_id: string;
+		status_ids: Array<string>;
+	};
 }

packages/megalodon/src/entities/results.ts

@@ -4,8 +4,8 @@
 
 namespace Entity {
 	export type Results = {
-    accounts: Array<Account>
-    statuses: Array<Status>
-    hashtags: Array<Tag>
-  }
+		accounts: Array<Account>;
+		statuses: Array<Status>;
+		hashtags: Array<Tag>;
+	};
 }

packages/megalodon/src/entities/scheduled_status.ts

@@ -2,9 +2,9 @@
 /// <reference path="status_params.ts" />
 namespace Entity {
 	export type ScheduledStatus = {
-    id: string
-    scheduled_at: string
-    params: StatusParams
-    media_attachments: Array<Attachment>
-  }
+		id: string;
+		scheduled_at: string;
+		params: StatusParams;
+		media_attachments: Array<Attachment>;
+	};
 }

packages/megalodon/src/entities/source.ts

@@ -1,10 +1,10 @@
 /// <reference path="field.ts" />
 namespace Entity {
 	export type Source = {
-    privacy: string | null
-    sensitive: boolean | null
-    language: string | null
-    note: string
-    fields: Array<Field>
-  }
+		privacy: string | null;
+		sensitive: boolean | null;
+		language: string | null;
+		note: string;
+		fields: Array<Field>;
+	};
 }

packages/megalodon/src/entities/stats.ts

@@ -1,7 +1,7 @@
 namespace Entity {
 	export type Stats = {
-    user_count: number
-    status_count: number
-    domain_count: number
-  }
+		user_count: number;
+		status_count: number;
+		domain_count: number;
+	};
 }

packages/megalodon/src/entities/status.ts

@@ -10,36 +10,36 @@
 
 namespace Entity {
 	export type Status = {
-    id: string
-    uri: string
-    url: string
-    account: Account
-    in_reply_to_id: string | null
-    in_reply_to_account_id: string | null
-    reblog: Status | null
-    content: string
-    plain_content: string | null
-    created_at: string
-    emojis: Emoji[]
-    replies_count: number
-    reblogs_count: number
-    favourites_count: number
-    reblogged: boolean | null
-    favourited: boolean | null
-    muted: boolean | null
-    sensitive: boolean
-    spoiler_text: string
-    visibility: 'public' | 'unlisted' | 'private' | 'direct'
-    media_attachments: Array<Attachment>
-    mentions: Array<Mention>
-    tags: Array<Tag>
-    card: Card | null
-    poll: Poll | null
-    application: Application | null
-    language: string | null
-    pinned: boolean | null
-    emoji_reactions: Array<Reaction>
-    quote: Status | null
-    bookmarked: boolean
-  }
+		id: string;
+		uri: string;
+		url: string;
+		account: Account;
+		in_reply_to_id: string | null;
+		in_reply_to_account_id: string | null;
+		reblog: Status | null;
+		content: string;
+		plain_content: string | null;
+		created_at: string;
+		emojis: Emoji[];
+		replies_count: number;
+		reblogs_count: number;
+		favourites_count: number;
+		reblogged: boolean | null;
+		favourited: boolean | null;
+		muted: boolean | null;
+		sensitive: boolean;
+		spoiler_text: string;
+		visibility: "public" | "unlisted" | "private" | "direct";
+		media_attachments: Array<Attachment>;
+		mentions: Array<Mention>;
+		tags: Array<Tag>;
+		card: Card | null;
+		poll: Poll | null;
+		application: Application | null;
+		language: string | null;
+		pinned: boolean | null;
+		emoji_reactions: Array<Reaction>;
+		quote: Status | null;
+		bookmarked: boolean;
+	};
 }

packages/megalodon/src/entities/status_edit.ts

@@ -10,14 +10,14 @@
 
 namespace Entity {
 	export type StatusEdit = {
-    account: Account
-    content: string
-    plain_content: string | null
-    created_at: string
-    emojis: Emoji[]
-    sensitive: boolean
-    spoiler_text: string
-    media_attachments: Array<Attachment>
-    poll: Poll | null
-  }
+		account: Account;
+		content: string;
+		plain_content: string | null;
+		created_at: string;
+		emojis: Emoji[];
+		sensitive: boolean;
+		spoiler_text: string;
+		media_attachments: Array<Attachment>;
+		poll: Poll | null;
+	};
 }

packages/megalodon/src/entities/status_params.ts

@@ -1,12 +1,12 @@
 namespace Entity {
 	export type StatusParams = {
-    text: string
-    in_reply_to_id: string | null
-    media_ids: Array<string> | null
-    sensitive: boolean | null
-    spoiler_text: string | null
-    visibility: 'public' | 'unlisted' | 'private' | 'direct'
-    scheduled_at: string | null
-    application_id: string
-  }
+		text: string;
+		in_reply_to_id: string | null;
+		media_ids: Array<string> | null;
+		sensitive: boolean | null;
+		spoiler_text: string | null;
+		visibility: "public" | "unlisted" | "private" | "direct";
+		scheduled_at: string | null;
+		application_id: string;
+	};
 }

packages/megalodon/src/entities/tag.ts

@@ -2,9 +2,9 @@
 
 namespace Entity {
 	export type Tag = {
-    name: string
-    url: string
-    history: Array<History> | null
-    following?: boolean
-  }
+		name: string;
+		url: string;
+		history: Array<History> | null;
+		following?: boolean;
+	};
 }

packages/megalodon/src/entities/token.ts

@@ -1,8 +1,8 @@
 namespace Entity {
 	export type Token = {
-    access_token: string
-    token_type: string
-    scope: string
-    created_at: number
-  }
+		access_token: string;
+		token_type: string;
+		scope: string;
+		created_at: number;
+	};
 }

packages/megalodon/src/entities/urls.ts

@@ -1,5 +1,5 @@
 namespace Entity {
 	export type URLs = {
-    streaming_api: string
-  }
+		streaming_api: string;
+	};
 }

packages/megalodon/src/misskey/api_client.ts

@@ -1,83 +1,83 @@
-import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
-import dayjs from 'dayjs'
-import FormData from 'form-data'
+import axios, { AxiosResponse, AxiosRequestConfig } from "axios";
+import dayjs from "dayjs";
+import FormData from "form-data";
 
-import { DEFAULT_UA } from '../default'
-import proxyAgent, { ProxyConfig } from '../proxy_config'
-import Response from '../response'
-import MisskeyEntity from './entity'
-import MegalodonEntity from '../entity'
-import WebSocket from './web_socket'
-import MisskeyNotificationType from './notification'
-import NotificationType from '../notification'
+import { DEFAULT_UA } from "../default";
+import proxyAgent, { ProxyConfig } from "../proxy_config";
+import Response from "../response";
+import MisskeyEntity from "./entity";
+import MegalodonEntity from "../entity";
+import WebSocket from "./web_socket";
+import MisskeyNotificationType from "./notification";
+import NotificationType from "../notification";
 
 namespace MisskeyAPI {
 	export namespace Entity {
-    export type App = MisskeyEntity.App
-    export type Announcement = MisskeyEntity.Announcement
-    export type Blocking = MisskeyEntity.Blocking
-    export type Choice = MisskeyEntity.Choice
-    export type CreatedNote = MisskeyEntity.CreatedNote
-    export type Emoji = MisskeyEntity.Emoji
-    export type Favorite = MisskeyEntity.Favorite
-    export type Field = MisskeyEntity.Field
-    export type File = MisskeyEntity.File
-    export type Follower = MisskeyEntity.Follower
-    export type Following = MisskeyEntity.Following
-    export type FollowRequest = MisskeyEntity.FollowRequest
-    export type Hashtag = MisskeyEntity.Hashtag
-    export type List = MisskeyEntity.List
-    export type Meta = MisskeyEntity.Meta
-    export type Mute = MisskeyEntity.Mute
-    export type Note = MisskeyEntity.Note
-    export type Notification = MisskeyEntity.Notification
-    export type Poll = MisskeyEntity.Poll
-    export type Reaction = MisskeyEntity.Reaction
-    export type Relation = MisskeyEntity.Relation
-    export type User = MisskeyEntity.User
-    export type UserDetail = MisskeyEntity.UserDetail
-    export type UserDetailMe = MisskeyEntity.UserDetailMe
-    export type GetAll = MisskeyEntity.GetAll
-    export type UserKey = MisskeyEntity.UserKey
-    export type Session = MisskeyEntity.Session
-		export type Stats = MisskeyEntity.Stats
-		export type State = MisskeyEntity.State
-    export type APIEmoji = { emojis: Emoji[] }
+		export type App = MisskeyEntity.App;
+		export type Announcement = MisskeyEntity.Announcement;
+		export type Blocking = MisskeyEntity.Blocking;
+		export type Choice = MisskeyEntity.Choice;
+		export type CreatedNote = MisskeyEntity.CreatedNote;
+		export type Emoji = MisskeyEntity.Emoji;
+		export type Favorite = MisskeyEntity.Favorite;
+		export type Field = MisskeyEntity.Field;
+		export type File = MisskeyEntity.File;
+		export type Follower = MisskeyEntity.Follower;
+		export type Following = MisskeyEntity.Following;
+		export type FollowRequest = MisskeyEntity.FollowRequest;
+		export type Hashtag = MisskeyEntity.Hashtag;
+		export type List = MisskeyEntity.List;
+		export type Meta = MisskeyEntity.Meta;
+		export type Mute = MisskeyEntity.Mute;
+		export type Note = MisskeyEntity.Note;
+		export type Notification = MisskeyEntity.Notification;
+		export type Poll = MisskeyEntity.Poll;
+		export type Reaction = MisskeyEntity.Reaction;
+		export type Relation = MisskeyEntity.Relation;
+		export type User = MisskeyEntity.User;
+		export type UserDetail = MisskeyEntity.UserDetail;
+		export type UserDetailMe = MisskeyEntity.UserDetailMe;
+		export type GetAll = MisskeyEntity.GetAll;
+		export type UserKey = MisskeyEntity.UserKey;
+		export type Session = MisskeyEntity.Session;
+		export type Stats = MisskeyEntity.Stats;
+		export type State = MisskeyEntity.State;
+		export type APIEmoji = { emojis: Emoji[] };
 	}
 
 	export class Converter {
-    private baseUrl: string
-    private instanceHost: string
-    private plcUrl: string
+		private baseUrl: string;
+		private instanceHost: string;
+		private plcUrl: string;
 		private modelOfAcct = {
 			id: "1",
-      username: 'none',
-      acct: 'none',
-      display_name: 'none',
+			username: "none",
+			acct: "none",
+			display_name: "none",
 			locked: true,
 			bot: true,
 			discoverable: false,
 			group: false,
-      created_at: '1971-01-01T00:00:00.000Z',
-      note: '',
-      url: 'plc',
-      avatar: 'plc',
-      avatar_static: 'plc',
-      header: 'plc',
-      header_static: 'plc',
+			created_at: "1971-01-01T00:00:00.000Z",
+			note: "",
+			url: "plc",
+			avatar: "plc",
+			avatar_static: "plc",
+			header: "plc",
+			header_static: "plc",
 			followers_count: -1,
 			following_count: 0,
 			statuses_count: 0,
-      last_status_at: '1971-01-01T00:00:00.000Z',
+			last_status_at: "1971-01-01T00:00:00.000Z",
 			noindex: true,
 			emojis: [],
 			fields: [],
-      moved: null
-    }
+			moved: null,
+		};
 
 		constructor(baseUrl: string) {
 			this.baseUrl = baseUrl;
-      this.instanceHost = baseUrl.substring(baseUrl.indexOf('//') + 2);
+			this.instanceHost = baseUrl.substring(baseUrl.indexOf("//") + 2);
 			this.plcUrl = `${baseUrl}/static-assets/transparent.png`;
 			this.modelOfAcct.url = this.plcUrl;
 			this.modelOfAcct.avatar = this.plcUrl;
@@ -86,17 +86,16 @@ namespace MisskeyAPI {
 			this.modelOfAcct.header_static = this.plcUrl;
 		}
 
-
-
 		// FIXME: Properly render MFM instead of just escaping HTML characters.
-    escapeMFM = (text: string): string => text
-      .replace(/&/g, '&')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#39;')
-      .replace(/`/g, '&#x60;')
-      .replace(/\r?\n/g, '<br>');
+		escapeMFM = (text: string): string =>
+			text
+				.replace(/&/g, "&amp;")
+				.replace(/</g, "&lt;")
+				.replace(/>/g, "&gt;")
+				.replace(/"/g, "&quot;")
+				.replace(/'/g, "&#39;")
+				.replace(/`/g, "&#x60;")
+				.replace(/\r?\n/g, "<br>");
 
 		emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => {
 			return {
@@ -104,22 +103,22 @@ namespace MisskeyAPI {
 				static_url: e.url,
 				url: e.url,
 				visible_in_picker: true,
-        category: e.category
-      }
-    }
+				category: e.category,
+			};
+		};
 
 		field = (f: Entity.Field): MegalodonEntity.Field => ({
 			name: f.name,
 			value: this.escapeMFM(f.value),
-      verified_at: null
-    })
+			verified_at: null,
+		});
 
 		user = (u: Entity.User): MegalodonEntity.Account => {
-      let acct = u.username
-      let acctUrl = `https://${u.host || this.instanceHost}/@${u.username}`
+			let acct = u.username;
+			let acctUrl = `https://${u.host || this.instanceHost}/@${u.username}`;
 			if (u.host) {
-        acct = `${u.username}@${u.host}`
-        acctUrl = `https://${u.host}/@${u.username}`
+				acct = `${u.username}@${u.host}`;
+				acctUrl = `https://${u.host}/@${u.username}`;
 			}
 			return {
 				id: u.id,
@@ -131,26 +130,31 @@ namespace MisskeyAPI {
 				followers_count: 0,
 				following_count: 0,
 				statuses_count: 0,
-        note: '',
+				note: "",
 				url: acctUrl,
 				avatar: u.avatarUrl,
 				avatar_static: u.avatarUrl,
 				header: this.plcUrl,
 				header_static: this.plcUrl,
-        emojis: u.emojis.map(e => this.emoji(e)),
+				emojis: u.emojis.map((e) => this.emoji(e)),
 				moved: null,
 				fields: [],
-        bot: false
-      }
-    }
+				bot: false,
+			};
+		};
 
-    userDetail = (u: Entity.UserDetail, host: string): MegalodonEntity.Account => {
-      let acct = u.username
-      host = host.replace('https://', '')
-      let acctUrl = `https://${host || u.host || this.instanceHost}/@${u.username}`
+		userDetail = (
+			u: Entity.UserDetail,
+			host: string,
+		): MegalodonEntity.Account => {
+			let acct = u.username;
+			host = host.replace("https://", "");
+			let acctUrl = `https://${host || u.host || this.instanceHost}/@${
+				u.username
+			}`;
 			if (u.host) {
-        acct = `${u.username}@${u.host}`
-        acctUrl = `https://${u.host}/@${u.username}`
+				acct = `${u.username}@${u.host}`;
+				acctUrl = `https://${u.host}/@${u.username}`;
 			}
 			return {
 				id: u.id,
@@ -162,70 +166,79 @@ namespace MisskeyAPI {
 				followers_count: u.followersCount,
 				following_count: u.followingCount,
 				statuses_count: u.notesCount,
-        note: u.description?.replace(/\n|\\n/g, '<br>') ?? '',
+				note: u.description?.replace(/\n|\\n/g, "<br>") ?? "",
 				url: acctUrl,
 				avatar: u.avatarUrl,
 				avatar_static: u.avatarUrl,
 				header: u.bannerUrl ?? this.plcUrl,
 				header_static: u.bannerUrl ?? this.plcUrl,
-        emojis: u.emojis.map(e => this.emoji(e)),
+				emojis: u.emojis.map((e) => this.emoji(e)),
 				moved: null,
-        fields: u.fields.map(f => this.field(f)),
+				fields: u.fields.map((f) => this.field(f)),
 				bot: u.isBot,
-      }
-    }
+			};
+		};
 
-    userPreferences = (u: MisskeyAPI.Entity.UserDetailMe, v: 'public' | 'unlisted' | 'private' | 'direct'): MegalodonEntity.Preferences => {
+		userPreferences = (
+			u: MisskeyAPI.Entity.UserDetailMe,
+			v: "public" | "unlisted" | "private" | "direct",
+		): MegalodonEntity.Preferences => {
 			return {
 				"reading:expand:media": "default",
 				"reading:expand:spoilers": false,
 				"posting:default:language": u.lang,
 				"posting:default:sensitive": u.alwaysMarkNsfw,
-        "posting:default:visibility": v
-      }
-    }
+				"posting:default:visibility": v,
+			};
+		};
 
-    visibility = (v: 'public' | 'home' | 'followers' | 'specified'): 'public' | 'unlisted' | 'private' | 'direct' => {
+		visibility = (
+			v: "public" | "home" | "followers" | "specified",
+		): "public" | "unlisted" | "private" | "direct" => {
 			switch (v) {
-        case 'public':
-          return v
-        case 'home':
-          return 'unlisted'
-        case 'followers':
-          return 'private'
-        case 'specified':
-          return 'direct'
-      }
+				case "public":
+					return v;
+				case "home":
+					return "unlisted";
+				case "followers":
+					return "private";
+				case "specified":
+					return "direct";
 			}
+		};
 
-    encodeVisibility = (v: 'public' | 'unlisted' | 'private' | 'direct'): 'public' | 'home' | 'followers' | 'specified' => {
+		encodeVisibility = (
+			v: "public" | "unlisted" | "private" | "direct",
+		): "public" | "home" | "followers" | "specified" => {
 			switch (v) {
-        case 'public':
-          return v
-        case 'unlisted':
-          return 'home'
-        case 'private':
-          return 'followers'
-        case 'direct':
-          return 'specified'
-      }
+				case "public":
+					return v;
+				case "unlisted":
+					return "home";
+				case "private":
+					return "followers";
+				case "direct":
+					return "specified";
 			}
+		};
 
-    fileType = (s: string): 'unknown' | 'image' | 'gifv' | 'video' | 'audio' => {
-      if (s === 'image/gif') {
-        return 'gifv'
+		fileType = (
+			s: string,
+		): "unknown" | "image" | "gifv" | "video" | "audio" => {
+			if (s === "image/gif") {
+				return "gifv";
 			}
-      if (s.includes('image')) {
-        return 'image'
+			if (s.includes("image")) {
+				return "image";
 			}
-      if (s.includes('video')) {
-        return 'video'
+			if (s.includes("video")) {
+				return "video";
 			}
-      if (s.includes('audio')) {
-        return 'audio'
-      }
-      return 'unknown'
+			if (s.includes("audio")) {
+				return "audio";
 			}
+			return "unknown";
+		};
 
 		file = (f: Entity.File): MegalodonEntity.Attachment => {
 			return {
@@ -237,20 +250,20 @@ namespace MisskeyAPI {
 				text_url: f.url,
 				meta: {
 					width: f.properties.width,
-          height: f.properties.height
+					height: f.properties.height,
 				},
 				description: f.comment,
-        blurhash: f.blurhash
-      }
-    }
+				blurhash: f.blurhash,
+			};
+		};
 
 		follower = (f: Entity.Follower): MegalodonEntity.Account => {
-      return this.user(f.follower)
-    }
+			return this.user(f.follower);
+		};
 
 		following = (f: Entity.Following): MegalodonEntity.Account => {
-      return this.user(f.followee)
-    }
+			return this.user(f.followee);
+		};
 
 		relation = (r: Entity.Relation): MegalodonEntity.Relationship => {
 			return {
@@ -265,35 +278,37 @@ namespace MisskeyAPI {
 				domain_blocking: false,
 				showing_reblogs: true,
 				endorsed: false,
-        notifying: false
-      }
-    }
+				notifying: false,
+			};
+		};
 
 		choice = (c: Entity.Choice): MegalodonEntity.PollOption => {
 			return {
 				title: c.text,
-        votes_count: c.votes
-      }
-    }
+				votes_count: c.votes,
+			};
+		};
 
 		poll = (p: Entity.Poll, id: string): MegalodonEntity.Poll => {
-      const now = dayjs()
-      const expire = dayjs(p.expiresAt)
-      const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0)
+			const now = dayjs();
+			const expire = dayjs(p.expiresAt);
+			const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0);
 			return {
 				id: id,
 				expires_at: p.expiresAt,
 				expired: now.isAfter(expire),
 				multiple: p.multiple,
 				votes_count: count,
-        options: p.choices.map(c => this.choice(c)),
-        voted: p.choices.some(c => c.isVoted),
-				own_votes: p.choices.filter(c => c.isVoted).map(c => p.choices.indexOf(c))
-      }
-    }
+				options: p.choices.map((c) => this.choice(c)),
+				voted: p.choices.some((c) => c.isVoted),
+				own_votes: p.choices
+					.filter((c) => c.isVoted)
+					.map((c) => p.choices.indexOf(c)),
+			};
+		};
 
 		note = (n: Entity.Note, host: string): MegalodonEntity.Status => {
-      host = host.replace('https://', '')
+			host = host.replace("https://", "");
 
 			return {
 				id: n.id,
@@ -303,20 +318,20 @@ namespace MisskeyAPI {
 				in_reply_to_id: n.replyId,
 				in_reply_to_account_id: n.reply?.userId ?? null,
 				reblog: n.renote ? this.note(n.renote, host) : null,
-        content: n.text ? this.escapeMFM(n.text) : '',
+				content: n.text ? this.escapeMFM(n.text) : "",
 				plain_content: n.text ? n.text : null,
 				created_at: n.createdAt,
-        emojis: n.emojis.map(e => this.emoji(e)),
+				emojis: n.emojis.map((e) => this.emoji(e)),
 				replies_count: n.repliesCount,
 				reblogs_count: n.renoteCount,
 				favourites_count: this.getTotalReactions(n.reactions),
 				reblogged: false,
 				favourited: !!n.myReaction,
 				muted: false,
-        sensitive: n.files ? n.files.some(f => f.isSensitive) : false,
-        spoiler_text: n.cw ? n.cw : '',
+				sensitive: n.files ? n.files.some((f) => f.isSensitive) : false,
+				spoiler_text: n.cw ? n.cw : "",
 				visibility: this.visibility(n.visibility),
-        media_attachments: n.files ? n.files.map(f => this.file(f)) : [],
+				media_attachments: n.files ? n.files.map((f) => this.file(f)) : [],
 				mentions: [],
 				tags: [],
 				card: null,
@@ -326,110 +341,124 @@ namespace MisskeyAPI {
 				pinned: null,
 				emoji_reactions: this.mapReactions(n.reactions, n.myReaction),
 				bookmarked: false,
-        quote: n.renote && n.text ? this.note(n.renote, host) : null
-      }
-    }
+				quote: n.renote && n.text ? this.note(n.renote, host) : null,
+			};
+		};
 
-    mapReactions = (r: { [key: string]: number }, myReaction?: string): Array<MegalodonEntity.Reaction> => {
-      return Object.keys(r).map(key => {
+		mapReactions = (
+			r: { [key: string]: number },
+			myReaction?: string,
+		): Array<MegalodonEntity.Reaction> => {
+			return Object.keys(r).map((key) => {
 				if (myReaction && key === myReaction) {
 					return {
 						count: r[key],
 						me: true,
-            name: key
-          }
+						name: key,
+					};
 				}
 				return {
 					count: r[key],
 					me: false,
-          name: key
-        }
-      })
-    }
+					name: key,
+				};
+			});
+		};
 
 		getTotalReactions = (r: { [key: string]: number }): number => {
-      return Object.values(r).length > 0 ? Object.values(r).reduce((previousValue, currentValue) => previousValue + currentValue) : 0
-    }
+			return Object.values(r).length > 0
+				? Object.values(r).reduce(
+						(previousValue, currentValue) => previousValue + currentValue,
+				  )
+				: 0;
+		};
 
-    reactions = (r: Array<Entity.Reaction>): Array<MegalodonEntity.Reaction> => {
-      const result: Array<MegalodonEntity.Reaction> = []
+		reactions = (
+			r: Array<Entity.Reaction>,
+		): Array<MegalodonEntity.Reaction> => {
+			const result: Array<MegalodonEntity.Reaction> = [];
 			for (const e of r) {
-        const i = result.findIndex(res => res.name === e.type)
+				const i = result.findIndex((res) => res.name === e.type);
 				if (i >= 0) {
-          result[i].count++
+					result[i].count++;
 				} else {
 					result.push({
 						count: 1,
 						me: false,
-            name: e.type
-          })
+						name: e.type,
+					});
 				}
 			}
-      return result
-    }
+			return result;
+		};
 
-    noteToConversation = (n: Entity.Note, host: string): MegalodonEntity.Conversation => {
-      const accounts: Array<MegalodonEntity.Account> = [this.user(n.user)]
+		noteToConversation = (
+			n: Entity.Note,
+			host: string,
+		): MegalodonEntity.Conversation => {
+			const accounts: Array<MegalodonEntity.Account> = [this.user(n.user)];
 			if (n.reply) {
-        accounts.push(this.user(n.reply.user))
+				accounts.push(this.user(n.reply.user));
 			}
 			return {
 				id: n.id,
 				accounts: accounts,
 				last_status: this.note(n, host),
-        unread: false
-      }
-    }
+				unread: false,
+			};
+		};
 
 		list = (l: Entity.List): MegalodonEntity.List => ({
 			id: l.id,
-      title: l.name
-    })
+			title: l.name,
+		});
 
-    encodeNotificationType = (e: MegalodonEntity.NotificationType): MisskeyEntity.NotificationType => {
+		encodeNotificationType = (
+			e: MegalodonEntity.NotificationType,
+		): MisskeyEntity.NotificationType => {
 			switch (e) {
 				case NotificationType.Follow:
-          return MisskeyNotificationType.Follow
+					return MisskeyNotificationType.Follow;
 				case NotificationType.Mention:
-          return MisskeyNotificationType.Reply
+					return MisskeyNotificationType.Reply;
 				case NotificationType.Favourite:
 				case NotificationType.EmojiReaction:
-          return MisskeyNotificationType.Reaction
+					return MisskeyNotificationType.Reaction;
 				case NotificationType.Reblog:
-          return MisskeyNotificationType.Renote
+					return MisskeyNotificationType.Renote;
 				case NotificationType.Poll:
-					return MisskeyNotificationType.PollEnded
+					return MisskeyNotificationType.PollEnded;
 				case NotificationType.FollowRequest:
-          return MisskeyNotificationType.ReceiveFollowRequest
+					return MisskeyNotificationType.ReceiveFollowRequest;
 				default:
-          return e
-      }
+					return e;
 			}
+		};
 
-    decodeNotificationType = (e: MisskeyEntity.NotificationType): MegalodonEntity.NotificationType => {
+		decodeNotificationType = (
+			e: MisskeyEntity.NotificationType,
+		): MegalodonEntity.NotificationType => {
 			switch (e) {
 				case MisskeyNotificationType.Follow:
-          return NotificationType.Follow
+					return NotificationType.Follow;
 				case MisskeyNotificationType.Mention:
 				case MisskeyNotificationType.Reply:
-          return NotificationType.Mention
+					return NotificationType.Mention;
 				case MisskeyNotificationType.Renote:
 				case MisskeyNotificationType.Quote:
-          return NotificationType.Reblog
+					return NotificationType.Reblog;
 				case MisskeyNotificationType.Reaction:
-          return NotificationType.EmojiReaction
+					return NotificationType.EmojiReaction;
 				case MisskeyNotificationType.PollEnded:
-					return NotificationType.Poll
+					return NotificationType.Poll;
 				case MisskeyNotificationType.ReceiveFollowRequest:
-          return NotificationType.FollowRequest
+					return NotificationType.FollowRequest;
 				case MisskeyNotificationType.FollowRequestAccepted:
-          return NotificationType.Follow
+					return NotificationType.Follow;
 				default:
-          return e
+					return e;
 			}
-    }
-
-
+		};
 
 		announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => ({
 			id: a.id,
@@ -446,43 +475,46 @@ namespace MisskeyAPI {
 			tags: [],
 			emojis: [],
 			reactions: [],
-    })
+		});
 
-    notification = (n: Entity.Notification, host: string): MegalodonEntity.Notification => {
+		notification = (
+			n: Entity.Notification,
+			host: string,
+		): MegalodonEntity.Notification => {
 			let notification = {
 				id: n.id,
 				account: n.user ? this.user(n.user) : this.modelOfAcct,
 				created_at: n.createdAt,
-        type: this.decodeNotificationType(n.type)
-      }
+				type: this.decodeNotificationType(n.type),
+			};
 			if (n.note) {
 				notification = Object.assign(notification, {
-          status: this.note(n.note, host)
-        })
+					status: this.note(n.note, host),
+				});
 				if (notification.type === NotificationType.Poll) {
 					notification = Object.assign(notification, {
-						account: this.note(n.note, host).account
-					})
+						account: this.note(n.note, host).account,
+					});
 				}
 			}
 			if (n.reaction) {
 				notification = Object.assign(notification, {
-          emoji: n.reaction
-        })
-      }
-      return notification
+					emoji: n.reaction,
+				});
 			}
+			return notification;
+		};
 
 		stats = (s: Entity.Stats): MegalodonEntity.Stats => {
 			return {
 				user_count: s.usersCount,
 				status_count: s.notesCount,
-        domain_count: s.instances
-      }
-    }
+				domain_count: s.instances,
+			};
+		};
 
 		meta = (m: Entity.Meta, s: Entity.Stats): MegalodonEntity.Instance => {
-      const wss = m.uri.replace(/^https:\/\//, 'wss://')
+			const wss = m.uri.replace(/^https:\/\//, "wss://");
 			return {
 				uri: m.uri,
 				title: m.name,
@@ -491,54 +523,67 @@ namespace MisskeyAPI {
 				version: m.version,
 				thumbnail: m.bannerUrl,
 				urls: {
-          streaming_api: `${wss}/streaming`
+					streaming_api: `${wss}/streaming`,
 				},
 				stats: this.stats(s),
 				languages: m.langs,
 				contact_account: null,
 				max_toot_chars: m.maxNoteTextLength,
-        registrations: !m.disableRegistration
-      }
-    }
+				registrations: !m.disableRegistration,
+			};
+		};
 
 		hashtag = (h: Entity.Hashtag): MegalodonEntity.Tag => {
 			return {
 				name: h.tag,
 				url: h.tag,
 				history: null,
-        following: false
-      }
-    }
+				following: false,
+			};
+		};
 	}
 
 	export const DEFAULT_SCOPE = [
-    'read:account',
-    'write:account',
-    'read:blocks',
-    'write:blocks',
-    'read:drive',
-    'write:drive',
-    'read:favorites',
-    'write:favorites',
-    'read:following',
-    'write:following',
-    'read:mutes',
-    'write:mutes',
-    'write:notes',
-    'read:notifications',
-    'write:notifications',
-    'read:reactions',
-    'write:reactions',
-    'write:votes'
-  ]
+		"read:account",
+		"write:account",
+		"read:blocks",
+		"write:blocks",
+		"read:drive",
+		"write:drive",
+		"read:favorites",
+		"write:favorites",
+		"read:following",
+		"write:following",
+		"read:mutes",
+		"write:mutes",
+		"write:notes",
+		"read:notifications",
+		"write:notifications",
+		"read:reactions",
+		"write:reactions",
+		"write:votes",
+	];
 
 	/**
 	 * Interface
 	 */
 	export interface Interface {
-    post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
-    cancel(): void
-    socket(channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list', listId?: string): WebSocket
+		post<T = any>(
+			path: string,
+			params?: any,
+			headers?: { [key: string]: string },
+		): Promise<Response<T>>;
+		cancel(): void;
+		socket(
+			channel:
+				| "user"
+				| "localTimeline"
+				| "hybridTimeline"
+				| "globalTimeline"
+				| "conversation"
+				| "list",
+			listId?: string,
+		): WebSocket;
 	}
 
 	/**
@@ -547,12 +592,12 @@ namespace MisskeyAPI {
 	 * Usign axios for request, you will handle promises.
 	 */
 	export class Client implements Interface {
-    private accessToken: string | null
-    private baseUrl: string
-    private userAgent: string
-    private abortController: AbortController
-    private proxyConfig: ProxyConfig | false = false
-    private converter: Converter
+		private accessToken: string | null;
+		private baseUrl: string;
+		private userAgent: string;
+		private abortController: AbortController;
+		private proxyConfig: ProxyConfig | false = false;
+		private converter: Converter;
 
 		/**
 		 * @param baseUrl hostname or base URL
@@ -561,14 +606,20 @@ namespace MisskeyAPI {
 		 * @param proxyConfig Proxy setting, or set false if don't use proxy.
 		 * @param converter Converter instance.
 		 */
-    constructor(baseUrl: string, accessToken: string | null, userAgent: string = DEFAULT_UA, proxyConfig: ProxyConfig | false = false, converter: Converter) {
-      this.accessToken = accessToken
-      this.baseUrl = baseUrl
-      this.userAgent = userAgent
-      this.proxyConfig = proxyConfig
-      this.abortController = new AbortController()
-      this.converter = converter
-      axios.defaults.signal = this.abortController.signal
+		constructor(
+			baseUrl: string,
+			accessToken: string | null,
+			userAgent: string = DEFAULT_UA,
+			proxyConfig: ProxyConfig | false = false,
+			converter: Converter,
+		) {
+			this.accessToken = accessToken;
+			this.baseUrl = baseUrl;
+			this.userAgent = userAgent;
+			this.proxyConfig = proxyConfig;
+			this.abortController = new AbortController();
+			this.converter = converter;
+			axios.defaults.signal = this.abortController.signal;
 		}
 
 		/**
@@ -577,38 +628,44 @@ namespace MisskeyAPI {
 		 * @param params Form data
 		 * @param headers Request header object
 		 */
-    public async post<T>(path: string, params: any = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+		public async post<T>(
+			path: string,
+			params: any = {},
+			headers: { [key: string]: string } = {},
+		): Promise<Response<T>> {
 			let options: AxiosRequestConfig = {
 				headers: headers,
 				maxContentLength: Infinity,
-        maxBodyLength: Infinity
-      }
+				maxBodyLength: Infinity,
+			};
 			if (this.proxyConfig) {
 				options = Object.assign(options, {
 					httpAgent: proxyAgent(this.proxyConfig),
-          httpsAgent: proxyAgent(this.proxyConfig)
-        })
+					httpsAgent: proxyAgent(this.proxyConfig),
+				});
 			}
-      let bodyParams = params
+			let bodyParams = params;
 			if (this.accessToken) {
 				if (params instanceof FormData) {
-          bodyParams.append('i', this.accessToken)
+					bodyParams.append("i", this.accessToken);
 				} else {
 					bodyParams = Object.assign(params, {
-            i: this.accessToken
-          })
+						i: this.accessToken,
+					});
 				}
 			}
 
-      return axios.post<T>(this.baseUrl + path, bodyParams, options).then((resp: AxiosResponse<T>) => {
+			return axios
+				.post<T>(this.baseUrl + path, bodyParams, options)
+				.then((resp: AxiosResponse<T>) => {
 					const res: Response<T> = {
 						data: resp.data,
 						status: resp.status,
 						statusText: resp.statusText,
-          headers: resp.headers
-        }
-        return res
-      })
+						headers: resp.headers,
+					};
+					return res;
+				});
 		}
 
 		/**
@@ -616,7 +673,7 @@ namespace MisskeyAPI {
 		 * @returns void
 		 */
 		public cancel(): void {
-      return this.abortController.abort()
+			return this.abortController.abort();
 		}
 
 		/**
@@ -626,20 +683,34 @@ namespace MisskeyAPI {
 		 * @param listId This parameter is required only list channel.
 		 */
 		public socket(
-      channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list',
-      listId?: string
+			channel:
+				| "user"
+				| "localTimeline"
+				| "hybridTimeline"
+				| "globalTimeline"
+				| "conversation"
+				| "list",
+			listId?: string,
 		): WebSocket {
 			if (!this.accessToken) {
-        throw new Error('accessToken is required')
+				throw new Error("accessToken is required");
 			}
-      const url = `${this.baseUrl}/streaming`
-      const streaming = new WebSocket(url, channel, this.accessToken, listId, this.userAgent, this.proxyConfig, this.converter)
+			const url = `${this.baseUrl}/streaming`;
+			const streaming = new WebSocket(
+				url,
+				channel,
+				this.accessToken,
+				listId,
+				this.userAgent,
+				this.proxyConfig,
+				this.converter,
+			);
 			process.nextTick(() => {
-        streaming.start()
-      })
-      return streaming
+				streaming.start();
+			});
+			return streaming;
 		}
 	}
 }
 
-export default MisskeyAPI
+export default MisskeyAPI;

packages/megalodon/src/misskey/entity.ts

@@ -25,4 +25,4 @@
 /// <reference path="entities/session.ts" />
 /// <reference path="entities/stats.ts" />
 
-export default MisskeyEntity
+export default MisskeyEntity;

packages/megalodon/src/misskey/notification.ts

@@ -1,16 +1,18 @@
-import MisskeyEntity from './entity'
+import MisskeyEntity from "./entity";
 
 namespace MisskeyNotificationType {
-  export const Follow: MisskeyEntity.NotificationType = 'follow'
-  export const Mention: MisskeyEntity.NotificationType = 'mention'
-  export const Reply: MisskeyEntity.NotificationType = 'reply'
-  export const Renote: MisskeyEntity.NotificationType = 'renote'
-  export const Quote: MisskeyEntity.NotificationType = 'quote'
-  export const Reaction: MisskeyEntity.NotificationType = 'favourite'
-	export const PollEnded: MisskeyEntity.NotificationType = 'pollEnded'
-  export const ReceiveFollowRequest: MisskeyEntity.NotificationType = 'receiveFollowRequest'
-  export const FollowRequestAccepted: MisskeyEntity.NotificationType = 'followRequestAccepted'
-  export const GroupInvited: MisskeyEntity.NotificationType = 'groupInvited'
+	export const Follow: MisskeyEntity.NotificationType = "follow";
+	export const Mention: MisskeyEntity.NotificationType = "mention";
+	export const Reply: MisskeyEntity.NotificationType = "reply";
+	export const Renote: MisskeyEntity.NotificationType = "renote";
+	export const Quote: MisskeyEntity.NotificationType = "quote";
+	export const Reaction: MisskeyEntity.NotificationType = "favourite";
+	export const PollEnded: MisskeyEntity.NotificationType = "pollEnded";
+	export const ReceiveFollowRequest: MisskeyEntity.NotificationType =
+		"receiveFollowRequest";
+	export const FollowRequestAccepted: MisskeyEntity.NotificationType =
+		"followRequestAccepted";
+	export const GroupInvited: MisskeyEntity.NotificationType = "groupInvited";
 }
 
-export default MisskeyNotificationType
+export default MisskeyNotificationType;

packages/megalodon/src/misskey/web_socket.ts

@@ -1,34 +1,43 @@
-import WS from 'ws'
-import dayjs, { Dayjs } from 'dayjs'
-import { v4 as uuid } from 'uuid'
-import { EventEmitter } from 'events'
-import { WebSocketInterface } from '../megalodon'
-import proxyAgent, { ProxyConfig } from '../proxy_config'
-import MisskeyAPI from './api_client'
+import WS from "ws";
+import dayjs, { Dayjs } from "dayjs";
+import { v4 as uuid } from "uuid";
+import { EventEmitter } from "events";
+import { WebSocketInterface } from "../megalodon";
+import proxyAgent, { ProxyConfig } from "../proxy_config";
+import MisskeyAPI from "./api_client";
 
 /**
  * WebSocket
  * Misskey is not support http streaming. It supports websocket instead of streaming.
  * So this class connect to Misskey server with WebSocket.
  */
-export default class WebSocket extends EventEmitter implements WebSocketInterface {
-  public url: string
-  public channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list'
-  public parser: any
-  public headers: { [key: string]: string }
-  public proxyConfig: ProxyConfig | false = false
-  public listId: string | null = null
-  private _converter: MisskeyAPI.Converter
-  private _accessToken: string
-  private _reconnectInterval: number
-  private _reconnectMaxAttempts: number
-  private _reconnectCurrentAttempts: number
-  private _connectionClosed: boolean
-  private _client: WS | null = null
-  private _channelID: string
-  private _pongReceivedTimestamp: Dayjs
-  private _heartbeatInterval: number = 60000
-  private _pongWaiting: boolean = false
+export default class WebSocket
+	extends EventEmitter
+	implements WebSocketInterface
+{
+	public url: string;
+	public channel:
+		| "user"
+		| "localTimeline"
+		| "hybridTimeline"
+		| "globalTimeline"
+		| "conversation"
+		| "list";
+	public parser: any;
+	public headers: { [key: string]: string };
+	public proxyConfig: ProxyConfig | false = false;
+	public listId: string | null = null;
+	private _converter: MisskeyAPI.Converter;
+	private _accessToken: string;
+	private _reconnectInterval: number;
+	private _reconnectMaxAttempts: number;
+	private _reconnectCurrentAttempts: number;
+	private _connectionClosed: boolean;
+	private _client: WS | null = null;
+	private _channelID: string;
+	private _pongReceivedTimestamp: Dayjs;
+	private _heartbeatInterval = 60000;
+	private _pongWaiting = false;
 
 	/**
 	 * @param url Full url of websocket: e.g. wss://misskey.io/streaming
@@ -38,66 +47,72 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 */
 	constructor(
 		url: string,
-    channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list',
+		channel:
+			| "user"
+			| "localTimeline"
+			| "hybridTimeline"
+			| "globalTimeline"
+			| "conversation"
+			| "list",
 		accessToken: string,
 		listId: string | undefined,
 		userAgent: string,
 		proxyConfig: ProxyConfig | false = false,
-    converter: MisskeyAPI.Converter
+		converter: MisskeyAPI.Converter,
 	) {
-    super()
-    this.url = url
-    this.parser = new Parser()
-    this.channel = channel
+		super();
+		this.url = url;
+		this.parser = new Parser();
+		this.channel = channel;
 		this.headers = {
-      'User-Agent': userAgent
-    }
+			"User-Agent": userAgent,
+		};
 		if (listId === undefined) {
-      this.listId = null
+			this.listId = null;
 		} else {
-      this.listId = listId
+			this.listId = listId;
 		}
-    this.proxyConfig = proxyConfig
-    this._accessToken = accessToken
-    this._reconnectInterval = 10000
-    this._reconnectMaxAttempts = Infinity
-    this._reconnectCurrentAttempts = 0
-    this._connectionClosed = false
-    this._channelID = uuid()
-    this._pongReceivedTimestamp = dayjs()
-    this._converter = converter
+		this.proxyConfig = proxyConfig;
+		this._accessToken = accessToken;
+		this._reconnectInterval = 10000;
+		this._reconnectMaxAttempts = Infinity;
+		this._reconnectCurrentAttempts = 0;
+		this._connectionClosed = false;
+		this._channelID = uuid();
+		this._pongReceivedTimestamp = dayjs();
+		this._converter = converter;
 	}
 
 	/**
 	 * Start websocket connection.
 	 */
 	public start() {
-    this._connectionClosed = false
-    this._resetRetryParams()
-    this._startWebSocketConnection()
+		this._connectionClosed = false;
+		this._resetRetryParams();
+		this._startWebSocketConnection();
 	}
 
 	private baseUrlToHost(baseUrl: string): string {
-    return baseUrl.replace('https://', '')
+		return baseUrl.replace("https://", "");
 	}
 
 	/**
 	 * Reset connection and start new websocket connection.
 	 */
 	private _startWebSocketConnection() {
-    this._resetConnection()
-    this._setupParser()
-    this._client = this._connect()
-    this._bindSocket(this._client)
+		this._resetConnection();
+		this._setupParser();
+		this._client = this._connect();
+		this._bindSocket(this._client);
 	}
 
 	/**
 	 * Stop current connection.
 	 */
 	public stop() {
-    this._connectionClosed = true
-    this._resetConnection()
-    this._resetRetryParams()
+		this._connectionClosed = true;
+		this._resetConnection();
+		this._resetRetryParams();
 	}
 
 	/**
@@ -105,13 +120,13 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 */
 	private _resetConnection() {
 		if (this._client) {
-      this._client.close(1000)
-      this._client.removeAllListeners()
-      this._client = null
+			this._client.close(1000);
+			this._client.removeAllListeners();
+			this._client = null;
 		}
 
 		if (this.parser) {
-      this.parser.removeAllListeners()
+			this.parser.removeAllListeners();
 		}
 	}
 
@@ -119,7 +134,7 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 * Resets the parameters used in reconnect.
 	 */
 	private _resetRetryParams() {
-    this._reconnectCurrentAttempts = 0
+		this._reconnectCurrentAttempts = 0;
 	}
 
 	/**
@@ -127,15 +142,15 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 */
 	private _connect(): WS {
 		let options: WS.ClientOptions = {
-      headers: this.headers
-    }
+			headers: this.headers,
+		};
 		if (this.proxyConfig) {
 			options = Object.assign(options, {
-        agent: proxyAgent(this.proxyConfig)
-      })
+				agent: proxyAgent(this.proxyConfig),
+			});
 		}
-    const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options)
-    return cli
+		const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options);
+		return cli;
 	}
 
 	/**
@@ -143,65 +158,65 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 */
 	private _channel() {
 		if (!this._client) {
-      return
+			return;
 		}
 		switch (this.channel) {
-      case 'conversation':
+			case "conversation":
 				this._client.send(
 					JSON.stringify({
-            type: 'connect',
+						type: "connect",
 						body: {
-              channel: 'main',
-              id: this._channelID
-            }
-          })
-        )
-        break
-      case 'user':
+							channel: "main",
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
+			case "user":
 				this._client.send(
 					JSON.stringify({
-            type: 'connect',
+						type: "connect",
 						body: {
-              channel: 'main',
-              id: this._channelID
-            }
-          })
-        )
+							channel: "main",
+							id: this._channelID,
+						},
+					}),
+				);
 				this._client.send(
 					JSON.stringify({
-            type: 'connect',
+						type: "connect",
 						body: {
-              channel: 'homeTimeline',
-              id: this._channelID
-            }
-          })
-        )
-        break
-      case 'list':
+							channel: "homeTimeline",
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
+			case "list":
 				this._client.send(
 					JSON.stringify({
-            type: 'connect',
+						type: "connect",
 						body: {
-              channel: 'userList',
+							channel: "userList",
 							id: this._channelID,
 							params: {
-                listId: this.listId
-              }
-            }
-          })
-        )
-        break
+								listId: this.listId,
+							},
+						},
+					}),
+				);
+				break;
 			default:
 				this._client.send(
 					JSON.stringify({
-            type: 'connect',
+						type: "connect",
 						body: {
 							channel: this.channel,
-              id: this._channelID
-            }
-          })
-        )
-        break
+							id: this._channelID,
+						},
+					}),
+				);
+				break;
 		}
 	}
 
@@ -214,23 +229,23 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 			// Skip reconnect when client is connecting.
 			// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365
 			if (this._client && this._client.readyState === WS.CONNECTING) {
-        return
+				return;
 			}
 
 			if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
-        this._reconnectCurrentAttempts++
-        this._clearBinding()
+				this._reconnectCurrentAttempts++;
+				this._clearBinding();
 				if (this._client) {
 					// In reconnect, we want to close the connection immediately,
 					// because recoonect is necessary when some problems occur.
-          this._client.terminate()
+					this._client.terminate();
 				}
 				// Call connect methods
-        console.log('Reconnecting')
-        this._client = this._connect()
-        this._bindSocket(this._client)
+				console.log("Reconnecting");
+				this._client = this._connect();
+				this._bindSocket(this._client);
 			}
-    }, this._reconnectInterval)
+		}, this._reconnectInterval);
 	}
 
 	/**
@@ -238,11 +253,11 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 */
 	private _clearBinding() {
 		if (this._client) {
-      this._client.removeAllListeners('close')
-      this._client.removeAllListeners('pong')
-      this._client.removeAllListeners('open')
-      this._client.removeAllListeners('message')
-      this._client.removeAllListeners('error')
+			this._client.removeAllListeners("close");
+			this._client.removeAllListeners("pong");
+			this._client.removeAllListeners("open");
+			this._client.removeAllListeners("message");
+			this._client.removeAllListeners("error");
 		}
 	}
 
@@ -251,76 +266,97 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
 	 * @param client A WebSocket instance.
 	 */
 	private _bindSocket(client: WS) {
-    client.on('close', (code: number, _reason: Buffer) => {
+		client.on("close", (code: number, _reason: Buffer) => {
 			if (code === 1000) {
-        this.emit('close', {})
+				this.emit("close", {});
 			} else {
-        console.log(`Closed connection with ${code}`)
+				console.log(`Closed connection with ${code}`);
 				if (!this._connectionClosed) {
-          this._reconnect()
+					this._reconnect();
 				}
 			}
-    })
-    client.on('pong', () => {
-      this._pongWaiting = false
-      this.emit('pong', {})
-      this._pongReceivedTimestamp = dayjs()
+		});
+		client.on("pong", () => {
+			this._pongWaiting = false;
+			this.emit("pong", {});
+			this._pongReceivedTimestamp = dayjs();
 			// It is required to anonymous function since get this scope in checkAlive.
-      setTimeout(() => this._checkAlive(this._pongReceivedTimestamp), this._heartbeatInterval)
-    })
-    client.on('open', () => {
-      this.emit('connect', {})
-      this._channel()
+			setTimeout(
+				() => this._checkAlive(this._pongReceivedTimestamp),
+				this._heartbeatInterval,
+			);
+		});
+		client.on("open", () => {
+			this.emit("connect", {});
+			this._channel();
 			// Call first ping event.
 			setTimeout(() => {
-        client.ping('')
-      }, 10000)
-    })
-    client.on('message', (data: WS.Data, isBinary: boolean) => {
-      this.parser.parse(data, isBinary, this._channelID)
-    })
-    client.on('error', (err: Error) => {
-      this.emit('error', err)
-    })
+				client.ping("");
+			}, 10000);
+		});
+		client.on("message", (data: WS.Data, isBinary: boolean) => {
+			this.parser.parse(data, isBinary, this._channelID);
+		});
+		client.on("error", (err: Error) => {
+			this.emit("error", err);
+		});
 	}
 
 	/**
 	 * Set up parser when receive message.
 	 */
 	private _setupParser() {
-    this.parser.on('update', (note: MisskeyAPI.Entity.Note) => {
-      this.emit('update', this._converter.note(note, this.baseUrlToHost(this.url)))
-    })
-    this.parser.on('notification', (notification: MisskeyAPI.Entity.Notification) => {
-      this.emit('notification', this._converter.notification(notification, this.baseUrlToHost(this.url)))
-    })
-    this.parser.on('conversation', (note: MisskeyAPI.Entity.Note) => {
-      this.emit('conversation', this._converter.noteToConversation(note, this.baseUrlToHost(this.url)))
-    })
-    this.parser.on('error', (err: Error) => {
-      this.emit('parser-error', err)
-    })
+		this.parser.on("update", (note: MisskeyAPI.Entity.Note) => {
+			this.emit(
+				"update",
+				this._converter.note(note, this.baseUrlToHost(this.url)),
+			);
+		});
+		this.parser.on(
+			"notification",
+			(notification: MisskeyAPI.Entity.Notification) => {
+				this.emit(
+					"notification",
+					this._converter.notification(
+						notification,
+						this.baseUrlToHost(this.url),
+					),
+				);
+			},
+		);
+		this.parser.on("conversation", (note: MisskeyAPI.Entity.Note) => {
+			this.emit(
+				"conversation",
+				this._converter.noteToConversation(note, this.baseUrlToHost(this.url)),
+			);
+		});
+		this.parser.on("error", (err: Error) => {
+			this.emit("parser-error", err);
+		});
 	}
 
 	/**
 	 * Call ping and wait to pong.
 	 */
 	private _checkAlive(timestamp: Dayjs) {
-    const now: Dayjs = dayjs()
+		const now: Dayjs = dayjs();
 		// Block multiple calling, if multiple pong event occur.
 		// It the duration is less than interval, through ping.
-    if (now.diff(timestamp) > this._heartbeatInterval - 1000 && !this._connectionClosed) {
+		if (
+			now.diff(timestamp) > this._heartbeatInterval - 1000 &&
+			!this._connectionClosed
+		) {
 			// Skip ping when client is connecting.
 			// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289
 			if (this._client && this._client.readyState !== WS.CONNECTING) {
-        this._pongWaiting = true
-        this._client.ping('')
+				this._pongWaiting = true;
+				this._client.ping("");
 				setTimeout(() => {
 					if (this._pongWaiting) {
-            this._pongWaiting = false
-            this._reconnect()
+						this._pongWaiting = false;
+						this._reconnect();
 					}
-        }, 10000)
+				}, 10000);
 			}
 		}
 	}
@@ -336,79 +372,87 @@ export class Parser extends EventEmitter {
 	 * @param channelID Parse only messages which has same channelID.
 	 */
 	public parse(data: WS.Data, isBinary: boolean, channelID: string) {
-    const message = isBinary ? data : data.toString()
-    if (typeof message !== 'string') {
-      this.emit('heartbeat', {})
-      return
+		const message = isBinary ? data : data.toString();
+		if (typeof message !== "string") {
+			this.emit("heartbeat", {});
+			return;
 		}
 
-    if (message === '') {
-      this.emit('heartbeat', {})
-      return
+		if (message === "") {
+			this.emit("heartbeat", {});
+			return;
 		}
 
 		let obj: {
-      type: string
+			type: string;
 			body: {
-        id: string
-        type: string
-        body: any
-      }
-    }
+				id: string;
+				type: string;
+				body: any;
+			};
+		};
 		let body: {
-      id: string
-      type: string
-      body: any
-    }
+			id: string;
+			type: string;
+			body: any;
+		};
 
 		try {
-      obj = JSON.parse(message)
-      if (obj.type !== 'channel') {
-        return
+			obj = JSON.parse(message);
+			if (obj.type !== "channel") {
+				return;
 			}
 			if (!obj.body) {
-        return
+				return;
 			}
-      body = obj.body
+			body = obj.body;
 			if (body.id !== channelID) {
-        return
+				return;
 			}
 		} catch (err) {
-      this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`))
-      return
+			this.emit(
+				"error",
+				new Error(
+					`Error parsing websocket reply: ${message}, error message: ${err}`,
+				),
+			);
+			return;
 		}
 
 		switch (body.type) {
-      case 'note':
-        this.emit('update', body.body as MisskeyAPI.Entity.Note)
-        break
-      case 'notification':
-        this.emit('notification', body.body as MisskeyAPI.Entity.Notification)
-        break
-      case 'mention': {
-        const note = body.body as MisskeyAPI.Entity.Note
-        if (note.visibility === 'specified') {
-          this.emit('conversation', note)
+			case "note":
+				this.emit("update", body.body as MisskeyAPI.Entity.Note);
+				break;
+			case "notification":
+				this.emit("notification", body.body as MisskeyAPI.Entity.Notification);
+				break;
+			case "mention": {
+				const note = body.body as MisskeyAPI.Entity.Note;
+				if (note.visibility === "specified") {
+					this.emit("conversation", note);
 				}
-        break
+				break;
 			}
 			// When renote and followed event, the same notification will be received.
-      case 'renote':
-      case 'followed':
-      case 'follow':
-      case 'unfollow':
-      case 'receiveFollowRequest':
-      case 'meUpdated':
-      case 'readAllNotifications':
-      case 'readAllUnreadSpecifiedNotes':
-      case 'readAllAntennas':
-      case 'readAllUnreadMentions':
-      case 'unreadNotification':
+			case "renote":
+			case "followed":
+			case "follow":
+			case "unfollow":
+			case "receiveFollowRequest":
+			case "meUpdated":
+			case "readAllNotifications":
+			case "readAllUnreadSpecifiedNotes":
+			case "readAllAntennas":
+			case "readAllUnreadMentions":
+			case "unreadNotification":
 				// Ignore these events
-        break
+				break;
 			default:
-        this.emit('error', new Error(`Unknown event has received: ${JSON.stringify(body)}`))
-        break
+				this.emit(
+					"error",
+					new Error(`Unknown event has received: ${JSON.stringify(body)}`),
+				);
+				break;
 		}
 	}
 }