add: Megalodon, initial mastodon api

.gitignore

@@ -58,6 +58,9 @@ ormconfig.json
 temp
 /packages/frontend/src/**/*.stories.ts
 
+# Sharkey
+/packages/megalodon/lib
+
 # blender backups
 *.blend1
 *.blend2

Dockerfile

@@ -24,6 +24,7 @@ COPY --link ["packages/backend/package.json", "./packages/backend/"]
 COPY --link ["packages/frontend/package.json", "./packages/frontend/"]
 COPY --link ["packages/sw/package.json", "./packages/sw/"]
 COPY --link ["packages/misskey-js/package.json", "./packages/misskey-js/"]
+COPY --link ["packages/megalodon/package.json", "./packages/megalodon/"]
 
 RUN --mount=type=cache,target=/root/.local/share/pnpm/store,sharing=locked \
 	pnpm i --frozen-lockfile --aggregate-output

packages/backend/package.json

@@ -99,6 +99,7 @@
 		"date-fns": "2.30.0",
 		"deep-email-validator": "0.1.21",
 		"fastify": "4.23.2",
+		"fastify-multer": "^2.0.3",
 		"feed": "4.2.2",
 		"file-type": "18.5.0",
 		"fluent-ffmpeg": "2.1.2",
@@ -116,6 +117,7 @@
 		"json5": "2.2.3",
 		"jsonld": "8.3.1",
 		"jsrsasign": "10.8.6",
+		"megalodon": "workspace:*",
 		"meilisearch": "0.34.2",
 		"mfm-js": "0.23.3",
 		"microformats-parser": "1.5.2",

packages/backend/src/server/ServerModule.ts

@@ -39,6 +39,7 @@ import { QueueStatsChannelService } from './api/stream/channels/queue-stats.js';
 import { ServerStatsChannelService } from './api/stream/channels/server-stats.js';
 import { UserListChannelService } from './api/stream/channels/user-list.js';
 import { OpenApiServerService } from './api/openapi/OpenApiServerService.js';
+import { MastodonApiServerService } from './api/mastodon/MastodonApiServerService.js';
 import { ClientLoggerService } from './web/ClientLoggerService.js';
 import { RoleTimelineChannelService } from './api/stream/channels/role-timeline.js';
 import { OAuth2ProviderService } from './oauth/OAuth2ProviderService.js';
@@ -84,6 +85,7 @@ import { OAuth2ProviderService } from './oauth/OAuth2ProviderService.js';
 		ServerStatsChannelService,
 		UserListChannelService,
 		OpenApiServerService,
+		MastodonApiServerService,
 		OAuth2ProviderService,
 	],
 	exports: [

packages/backend/src/server/ServerService.ts

@@ -30,6 +30,7 @@ import { WellKnownServerService } from './WellKnownServerService.js';
 import { FileServerService } from './FileServerService.js';
 import { ClientServerService } from './web/ClientServerService.js';
 import { OpenApiServerService } from './api/openapi/OpenApiServerService.js';
+import { MastodonApiServerService } from './api/mastodon/MastodonApiServerService.js';
 import { OAuth2ProviderService } from './oauth/OAuth2ProviderService.js';
 
 const _dirname = fileURLToPath(new URL('.', import.meta.url));
@@ -56,6 +57,7 @@ export class ServerService implements OnApplicationShutdown {
 		private userEntityService: UserEntityService,
 		private apiServerService: ApiServerService,
 		private openApiServerService: OpenApiServerService,
+		private mastodonApiServerService: MastodonApiServerService,
 		private streamingApiServerService: StreamingApiServerService,
 		private activityPubServerService: ActivityPubServerService,
 		private wellKnownServerService: WellKnownServerService,
@@ -95,6 +97,7 @@ export class ServerService implements OnApplicationShutdown {
 
 		fastify.register(this.apiServerService.createServer, { prefix: '/api' });
 		fastify.register(this.openApiServerService.createServer);
+		fastify.register(this.mastodonApiServerService.createServer, { prefix: '/api' });
 		fastify.register(this.fileServerService.createServer);
 		fastify.register(this.activityPubServerService.createServer);
 		fastify.register(this.nodeinfoServerService.createServer);

packages/backend/src/server/api/mastodon/MastodonApiServerService.ts

+import { fileURLToPath } from 'node:url';
+import { Inject, Injectable } from '@nestjs/common';
+import type { UsersRepository } from '@/models/_.js';
+import { DI } from '@/di-symbols.js';
+import { bindThis } from '@/decorators.js';
+import megalodon, { MegalodonInterface } from "megalodon";
+import type { FastifyInstance, FastifyPluginOptions } from 'fastify';
+import { convertId, IdConvertType as IdType, convertAccount, convertAnnouncement, convertFilter, convertAttachment } from './converters.js';
+import { IsNull } from 'typeorm';
+import type { Config } from '@/config.js';
+import { getInstance } from './endpoints/meta.js';
+import { MetaService } from '@/core/MetaService.js';
+import multer from 'fastify-multer';
+
+const staticAssets = fileURLToPath(new URL('../../../../assets/', import.meta.url));
+
+export function getClient(BASE_URL: string, authorization: string | undefined): MegalodonInterface {
+	const accessTokenArr = authorization?.split(" ") ?? [null];
+	const accessToken = accessTokenArr[accessTokenArr.length - 1];
+	const generator = (megalodon as any).default;
+	const client = generator(BASE_URL, accessToken) as MegalodonInterface;
+	return client;
+}
+
+@Injectable()
+export class MastodonApiServerService {
+	constructor(
+		@Inject(DI.usersRepository)
+		private usersRepository: UsersRepository,
+        @Inject(DI.config)
+		private config: Config,
+        private metaService: MetaService,
+	) { }
+
+	@bindThis
+	public createServer(fastify: FastifyInstance, _options: FastifyPluginOptions, done: (err?: Error) => void) {
+        const upload = multer({
+            storage: multer.diskStorage({}),
+            limits: {
+                fileSize: this.config.maxFileSize || 262144000,
+                files: 1,
+            },
+        });
+
+        fastify.register(multer.contentParser);
+
+        fastify.get("/v1/custom_emojis", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens);
+            try {
+                const data = await client.getInstanceCustomEmojis();
+                reply.send(data.data);
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+    
+        fastify.get("/v1/instance", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens); // we are using this here, because in private mode some info isnt
+            // displayed without being logged in
+            try {
+                const data = await client.getInstance();
+                const admin = await this.usersRepository.findOne({
+                    where: {
+                        host: IsNull(),
+                        isRoot: true,
+                        isDeleted: false,
+                        isSuspended: false,
+                    },
+                    order: { id: "ASC" },
+                });
+                const contact = admin == null ? null : convertAccount((await client.getAccount(admin.id)).data);
+                reply.send(await getInstance(data.data, contact, this.config, await this.metaService.fetch()));
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+    
+        fastify.get("/v1/announcements", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens);
+            try {
+                const data = await client.getInstanceAnnouncements();
+                reply.send(data.data.map((announcement) => convertAnnouncement(announcement)));
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+    
+        fastify.post<{ Body: { id: string } }>("/v1/announcements/:id/dismiss", async (_request, reply) => {
+                const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+                const accessTokens = _request.headers.authorization;
+                const client = getClient(BASE_URL, accessTokens);
+                try {
+                    const data = await client.dismissInstanceAnnouncement(
+                        convertId(_request.body['id'], IdType.SharkeyId)
+                    );
+                    reply.send(data.data);
+                } catch (e: any) {
+                    console.error(e);
+                    reply.code(401).send(e.response.data);
+                }
+            },
+        );
+
+        fastify.post("/v1/media", { preHandler: upload.single('file') }, async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens);
+            try {
+                const multipartData = await _request.file;
+                if (!multipartData) {
+                    reply.code(401).send({ error: "No image" });
+                    return;
+                }
+                const data = await client.uploadMedia(multipartData);
+                reply.send(convertAttachment(data.data as Entity.Attachment));
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+
+        fastify.post("/v2/media", { preHandler: upload.single('file') }, async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens);
+            try {
+                const multipartData = await _request.file;
+                if (!multipartData) {
+                    reply.code(401).send({ error: "No image" });
+                    return;
+                }
+                const data = await client.uploadMedia(multipartData, _request.body!);
+                reply.send(convertAttachment(data.data as Entity.Attachment));
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });        
+    
+        fastify.get("/v1/filters", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens); // we are using this here, because in private mode some info isnt
+            // displayed without being logged in
+            try {
+                const data = await client.getFilters();
+                reply.send(data.data.map((filter) => convertFilter(filter)));
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+    
+        fastify.get("/v1/trends", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens); // we are using this here, because in private mode some info isnt
+            // displayed without being logged in
+            try {
+                const data = await client.getInstanceTrends();
+                reply.send(data.data);
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });
+    
+        fastify.get("/v1/preferences", async (_request, reply) => {
+            const BASE_URL = `${_request.protocol}://${_request.hostname}`;
+            const accessTokens = _request.headers.authorization;
+            const client = getClient(BASE_URL, accessTokens); // we are using this here, because in private mode some info isnt
+            // displayed without being logged in
+            try {
+                const data = await client.getPreferences();
+                reply.send(data.data);
+            } catch (e: any) {
+                console.error(e);
+                reply.code(401).send(e.response.data);
+            }
+        });    
+		done();
+	}
+}
\ No newline at end of file

packages/backend/src/server/api/mastodon/converters.ts

+import { Entity } from "megalodon";
+
+const CHAR_COLLECTION: string = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+export enum IdConvertType {
+    MastodonId,
+    SharkeyId,
+}
+
+export function convertId(in_id: string, id_convert_type: IdConvertType): string {
+    switch (id_convert_type) {
+        case IdConvertType.MastodonId:
+          let out: bigint = BigInt(0);
+          const lowerCaseId = in_id.toLowerCase();
+          for (let i = 0; i < lowerCaseId.length; i++) {
+            const charValue = numFromChar(lowerCaseId.charAt(i));
+            out += BigInt(charValue) * BigInt(36) ** BigInt(i);
+          }
+          return out.toString();
+    
+        case IdConvertType.SharkeyId:
+          let input: bigint = BigInt(in_id);
+          let outStr = '';
+          while (input > BigInt(0)) {
+            const remainder = Number(input % BigInt(36));
+            outStr = charFromNum(remainder) + outStr;
+            input /= BigInt(36);
+          }
+          return outStr;
+    
+        default:
+          throw new Error('Invalid ID conversion type');
+    }
+}
+
+function numFromChar(character: string): number {
+    for (let i = 0; i < CHAR_COLLECTION.length; i++) {
+      if (CHAR_COLLECTION.charAt(i) === character) {
+        return i;
+      }
+    }
+
+    throw new Error('Invalid character in parsed base36 id');
+}
+
+function charFromNum(number: number): string {
+    if (number >= 0 && number < CHAR_COLLECTION.length) {
+      return CHAR_COLLECTION.charAt(number);
+    } else {
+      throw new Error('Invalid number for base-36 encoding');
+    }
+}
+
+function simpleConvert(data: any) {
+	// copy the object to bypass weird pass by reference bugs
+	const result = Object.assign({}, data);
+	result.id = convertId(data.id, IdConvertType.MastodonId);
+	return result;
+}
+
+export function convertAccount(account: Entity.Account) {
+	return simpleConvert(account);
+}
+export function convertAnnouncement(announcement: Entity.Announcement) {
+	return simpleConvert(announcement);
+}
+export function convertAttachment(attachment: Entity.Attachment) {
+	return simpleConvert(attachment);
+}
+export function convertFilter(filter: Entity.Filter) {
+	return simpleConvert(filter);
+}
+export function convertList(list: Entity.List) {
+	return simpleConvert(list);
+}
+export function convertFeaturedTag(tag: Entity.FeaturedTag) {
+	return simpleConvert(tag);
+}
+
+export function convertNotification(notification: Entity.Notification) {
+	notification.account = convertAccount(notification.account);
+	notification.id = convertId(notification.id, IdConvertType.MastodonId);
+	if (notification.status)
+		notification.status = convertStatus(notification.status);
+	if (notification.reaction)
+		notification.reaction = convertReaction(notification.reaction);
+	return notification;
+}
+
+export function convertPoll(poll: Entity.Poll) {
+	return simpleConvert(poll);
+}
+export function convertReaction(reaction: Entity.Reaction) {
+	if (reaction.accounts) {
+		reaction.accounts = reaction.accounts.map(convertAccount);
+	}
+	return reaction;
+}
+export function convertRelationship(relationship: Entity.Relationship) {
+	return simpleConvert(relationship);
+}
+
+export function convertStatus(status: Entity.Status) {
+	status.account = convertAccount(status.account);
+	status.id = convertId(status.id, IdConvertType.MastodonId);
+	if (status.in_reply_to_account_id)
+		status.in_reply_to_account_id = convertId(
+			status.in_reply_to_account_id,
+			IdConvertType.MastodonId,
+		);
+	if (status.in_reply_to_id)
+		status.in_reply_to_id = convertId(status.in_reply_to_id, IdConvertType.MastodonId);
+	status.media_attachments = status.media_attachments.map((attachment) =>
+		convertAttachment(attachment),
+	);
+	status.mentions = status.mentions.map((mention) => ({
+		...mention,
+		id: convertId(mention.id, IdConvertType.MastodonId),
+	}));
+	if (status.poll) status.poll = convertPoll(status.poll);
+	if (status.reblog) status.reblog = convertStatus(status.reblog);
+	if (status.quote) status.quote = convertStatus(status.quote);
+	status.reactions = status.reactions.map(convertReaction);
+
+	return status;
+}
+
+export function convertConversation(conversation: Entity.Conversation) {
+	conversation.id = convertId(conversation.id, IdConvertType.MastodonId);
+	conversation.accounts = conversation.accounts.map(convertAccount);
+	if (conversation.last_status) {
+		conversation.last_status = convertStatus(conversation.last_status);
+	}
+
+	return conversation;
+}

packages/backend/src/server/api/mastodon/endpoints/meta.ts

+import { Entity } from "megalodon";
+import { MAX_NOTE_TEXT_LENGTH, FILE_TYPE_BROWSERSAFE } from "@/const.js";
+import type { Config } from '@/config.js';
+import type { MiMeta } from "@/models/Meta.js";
+
+export async function getInstance(
+	response: Entity.Instance,
+	contact: Entity.Account,
+    config: Config,
+    meta: MiMeta,
+) {
+	return {
+		uri: config.url,
+		title: meta.name || "Sharkey",
+		short_description:
+			meta.description?.substring(0, 50) || "See real server website",
+		description:
+			meta.description ||
+			"This is a vanilla Sharkey Instance. It doesn't seem to have a description.",
+		email: response.email || "",
+		version: `3.0.0 (compatible; Sharkey ${config.version})`,
+		urls: response.urls,
+		stats: {
+			user_count: response.stats.user_count,
+			status_count: response.stats.status_count,
+			domain_count: response.stats.domain_count,
+		},
+		thumbnail: meta.backgroundImageUrl || "/static-assets/transparent.png",
+		languages: meta.langs,
+		registrations: !meta.disableRegistration || response.registrations,
+		approval_required: !response.registrations,
+		invites_enabled: response.registrations,
+		configuration: {
+			accounts: {
+				max_featured_tags: 20,
+			},
+			statuses: {
+				max_characters: MAX_NOTE_TEXT_LENGTH,
+				max_media_attachments: 16,
+				characters_reserved_per_url: response.uri.length,
+			},
+			media_attachments: {
+				supported_mime_types: FILE_TYPE_BROWSERSAFE,
+				image_size_limit: 10485760,
+				image_matrix_limit: 16777216,
+				video_size_limit: 41943040,
+				video_frame_rate_limit: 60,
+				video_matrix_limit: 2304000,
+			},
+			polls: {
+				max_options: 10,
+				max_characters_per_option: 50,
+				min_expiration: 50,
+				max_expiration: 2629746,
+			},
+			reactions: {
+				max_reactions: 1,
+			},
+		},
+		contact_account: contact,
+		rules: [],
+	};
+}
\ No newline at end of file

packages/megalodon/package.json

+{
+  "name": "megalodon",
+  "private": true,
+  "main": "./lib/src/index.js",
+  "typings": "./lib/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p ./",
+		"build:debug": "pnpm run build",
+    "lint": "pnpm biome check **/*.ts --apply",
+		"format": "pnpm biome format --write src/**/*.ts",
+    "doc": "typedoc --out ../docs ./src",
+    "test": "NODE_ENV=test jest -u --maxWorkers=3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "moduleNameMapper": {
+      "^@/(.+)": "<rootDir>/src/$1",
+      "^~/(.+)": "<rootDir>/$1"
+    },
+    "testMatch": [
+      "**/test/**/*.spec.ts"
+    ],
+    "preset": "ts-jest/presets/default",
+    "transform": {
+      "^.+\\.(ts|tsx)$": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "testEnvironment": "node"
+  },
+  "dependencies": {
+    "@types/oauth": "^0.9.0",
+    "@types/ws": "^8.5.4",
+    "axios": "1.2.2",
+    "dayjs": "^1.11.7",
+    "form-data": "^4.0.0",
+    "https-proxy-agent": "^5.0.1",
+    "oauth": "^0.10.0",
+    "object-assign-deep": "^0.4.0",
+    "parse-link-header": "^2.0.0",
+    "socks-proxy-agent": "^7.0.0",
+    "typescript": "4.9.4",
+    "uuid": "^9.0.0",
+    "ws": "8.12.0",
+    "async-lock": "1.4.0"
+  },
+  "devDependencies": {
+    "@types/core-js": "^2.5.0",
+    "@types/form-data": "^2.5.0",
+    "@types/jest": "^29.4.0",
+    "@types/object-assign-deep": "^0.4.0",
+    "@types/parse-link-header": "^2.0.0",
+    "@types/uuid": "^9.0.0",
+		"@types/node": "18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.49.0",
+    "@typescript-eslint/parser": "^5.49.0",
+    "@types/async-lock": "1.4.0",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-node": "^11.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-standard": "^5.0.0",
+    "jest": "^29.4.0",
+    "jest-worker": "^29.4.0",
+    "lodash": "^4.17.14",
+    "prettier": "^2.8.3",
+    "ts-jest": "^29.0.5",
+    "typedoc": "^0.23.24"
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  }
+}

packages/megalodon/src/axios.d.ts

+declare module "axios/lib/adapters/http";

packages/megalodon/src/cancel.ts

+export class RequestCanceledError extends Error {
+	public isCancel: boolean;
+
+	constructor(msg: string) {
+		super(msg);
+		this.isCancel = true;
+		Object.setPrototypeOf(this, RequestCanceledError);
+	}
+}
+
+export const isCancel = (value: any): boolean => {
+	return value && value.isCancel;
+};

packages/megalodon/src/converter.ts

+import MisskeyAPI from "./misskey/api_client";
+
+export default MisskeyAPI.Converter;

packages/megalodon/src/default.ts

+export const NO_REDIRECT = "urn:ietf:wg:oauth:2.0:oob";
+export const DEFAULT_SCOPE = ["read", "write", "follow"];
+export const DEFAULT_UA = "megalodon";

packages/megalodon/src/entities/account.ts

+/// <reference path="emoji.ts" />
+/// <reference path="source.ts" />
+/// <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;
+	};
+}

packages/megalodon/src/entities/activity.ts

+namespace Entity {
+	export type Activity = {
+		week: string;
+		statuses: string;
+		logins: string;
+		registrations: string;
+	};
+}

packages/megalodon/src/entities/announcement.ts

+/// <reference path="tag.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="reaction.ts" />
+
+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>;
+	};
+
+	export type AnnouncementAccount = {
+		id: string;
+		username: string;
+		url: string;
+		acct: string;
+	};
+
+	export type AnnouncementStatus = {
+		id: string;
+		url: string;
+	};
+}

packages/megalodon/src/entities/application.ts

+namespace Entity {
+	export type Application = {
+		name: string;
+		website?: string | null;
+		vapid_key?: string | null;
+	};
+}

packages/megalodon/src/entities/async_attachment.ts

+/// <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;
+	};
+}

packages/megalodon/src/entities/attachment.ts

+namespace Entity {
+	export type Sub = {
+		// For Image, Gifv, and Video
+		width?: number;
+		height?: number;
+		size?: string;
+		aspect?: number;
+
+		// For Gifv and Video
+		frame_rate?: string;
+
+		// For Audio, Gifv, and Video
+		duration?: number;
+		bitrate?: number;
+	};
+
+	export type Focus = {
+		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;
+	};
+
+	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;
+	};
+}

packages/megalodon/src/entities/card.ts

+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;
+	};
+}