upd: megalodon to v7

packages/megalodon/src/friendica/api_client.ts

@@ -0,0 +1,768 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
+import objectAssignDeep from 'object-assign-deep'
+
+import WebSocket from './web_socket'
+import Response from '../response'
+import { RequestCanceledError } from '../cancel'
+import proxyAgent, { ProxyConfig } from '../proxy_config'
+import { NO_REDIRECT, DEFAULT_SCOPE, DEFAULT_UA } from '../default'
+import FriendicaEntity from './entity'
+import MegalodonEntity from '../entity'
+import NotificationType, { UnknownNotificationTypeError } from '../notification'
+import FriendicaNotificationType from './notification'
+
+namespace FriendicaAPI {
+  /**
+   * Interface
+   */
+  export interface Interface {
+    get<T = any>(path: string, params?: any, headers?: { [key: string]: string }, pathIsFullyQualified?: boolean): Promise<Response<T>>
+    put<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    putForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    patch<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    patchForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    postForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    del<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    cancel(): void
+    socket(path: string, stream: string, params?: string): WebSocket
+  }
+
+  /**
+   * Friendica API client.
+   *
+   * Using axios for request, you will handle promises.
+   */
+  export class Client implements Interface {
+    static DEFAULT_SCOPE = DEFAULT_SCOPE
+    static DEFAULT_URL = 'https://mastodon.social'
+    static NO_REDIRECT = NO_REDIRECT
+
+    private accessToken: string | null
+    private baseUrl: string
+    private userAgent: string
+    private abortController: AbortController
+    private proxyConfig: ProxyConfig | false = false
+
+    /**
+     * @param baseUrl hostname or base URL
+     * @param accessToken access token from OAuth2 authorization
+     * @param userAgent UserAgent is specified in header on request.
+     * @param proxyConfig Proxy setting, or set false if don't use proxy.
+     */
+    constructor(
+      baseUrl: string,
+      accessToken: string | null = null,
+      userAgent: string = DEFAULT_UA,
+      proxyConfig: ProxyConfig | false = false
+    ) {
+      this.accessToken = accessToken
+      this.baseUrl = baseUrl
+      this.userAgent = userAgent
+      this.proxyConfig = proxyConfig
+      this.abortController = new AbortController()
+      axios.defaults.signal = this.abortController.signal
+    }
+
+    /**
+     * GET request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Query parameters
+     * @param headers Request header object
+     */
+    public async get<T>(
+      path: string,
+      params = {},
+      headers: { [key: string]: string } = {},
+      pathIsFullyQualified = false
+    ): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        params: params,
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .get<T>((pathIsFullyQualified ? '' : this.baseUrl) + path, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PUT request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async put<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .put<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PUT request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async putForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .putForm<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PATCH request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async patch<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .patch<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PATCH request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async patchForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .patchForm<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * POST request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async post<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios.post<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
+        const res: Response<T> = {
+          data: resp.data,
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: resp.headers
+        }
+        return res
+      })
+    }
+
+    /**
+     * POST request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async postForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios.postForm<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
+        const res: Response<T> = {
+          data: resp.data,
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: resp.headers
+        }
+        return res
+      })
+    }
+
+    /**
+     * DELETE request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async del<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        data: params,
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .delete(this.baseUrl + path, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * Cancel all requests in this instance.
+     * @returns void
+     */
+    public cancel(): void {
+      return this.abortController.abort()
+    }
+
+    /**
+     * Get connection and receive websocket connection for Pleroma API.
+     *
+     * @param path relative path from baseUrl: normally it is `/streaming`.
+     * @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
+     * @returns WebSocket, which inherits from EventEmitter
+     */
+    public socket(path: string, stream: string, params?: string): WebSocket {
+      if (!this.accessToken) {
+        throw new Error('accessToken is required')
+      }
+      const url = this.baseUrl + path
+      const streaming = new WebSocket(url, stream, params, this.accessToken, this.userAgent, this.proxyConfig)
+      process.nextTick(() => {
+        streaming.start()
+      })
+      return streaming
+    }
+  }
+
+  export namespace Entity {
+    export type Account = FriendicaEntity.Account
+    export type Activity = FriendicaEntity.Activity
+    export type Application = FriendicaEntity.Application
+    export type AsyncAttachment = FriendicaEntity.AsyncAttachment
+    export type Attachment = FriendicaEntity.Attachment
+    export type Card = FriendicaEntity.Card
+    export type Context = FriendicaEntity.Context
+    export type Conversation = FriendicaEntity.Conversation
+    export type Emoji = FriendicaEntity.Emoji
+    export type FeaturedTag = FriendicaEntity.FeaturedTag
+    export type Field = FriendicaEntity.Field
+    export type Filter = FriendicaEntity.Filter
+    export type FollowRequest = FriendicaEntity.FollowRequest
+    export type History = FriendicaEntity.History
+    export type IdentityProof = FriendicaEntity.IdentityProof
+    export type Instance = FriendicaEntity.Instance
+    export type List = FriendicaEntity.List
+    export type Marker = FriendicaEntity.Marker
+    export type Mention = FriendicaEntity.Mention
+    export type Notification = FriendicaEntity.Notification
+    export type Poll = FriendicaEntity.Poll
+    export type PollOption = FriendicaEntity.PollOption
+    export type Preferences = FriendicaEntity.Preferences
+    export type PushSubscription = FriendicaEntity.PushSubscription
+    export type Relationship = FriendicaEntity.Relationship
+    export type Report = FriendicaEntity.Report
+    export type Results = FriendicaEntity.Results
+    export type ScheduledStatus = FriendicaEntity.ScheduledStatus
+    export type Source = FriendicaEntity.Source
+    export type Stats = FriendicaEntity.Stats
+    export type Status = FriendicaEntity.Status
+    export type StatusParams = FriendicaEntity.StatusParams
+    export type StatusSource = FriendicaEntity.StatusSource
+    export type Tag = FriendicaEntity.Tag
+    export type Token = FriendicaEntity.Token
+    export type URLs = FriendicaEntity.URLs
+  }
+
+  export namespace Converter {
+    export const encodeNotificationType = (
+      t: MegalodonEntity.NotificationType
+    ): FriendicaEntity.NotificationType | UnknownNotificationTypeError => {
+      switch (t) {
+        case NotificationType.Follow:
+          return FriendicaNotificationType.Follow
+        case NotificationType.Favourite:
+          return FriendicaNotificationType.Favourite
+        case NotificationType.Reblog:
+          return FriendicaNotificationType.Reblog
+        case NotificationType.Mention:
+          return FriendicaNotificationType.Mention
+        case NotificationType.FollowRequest:
+          return FriendicaNotificationType.FollowRequest
+        case NotificationType.Status:
+          return FriendicaNotificationType.Status
+        case NotificationType.PollExpired:
+          return FriendicaNotificationType.Poll
+        case NotificationType.Update:
+          return FriendicaNotificationType.Update
+        default:
+          return new UnknownNotificationTypeError()
+      }
+    }
+
+    export const decodeNotificationType = (
+      t: FriendicaEntity.NotificationType
+    ): MegalodonEntity.NotificationType | UnknownNotificationTypeError => {
+      switch (t) {
+        case FriendicaNotificationType.Follow:
+          return NotificationType.Follow
+        case FriendicaNotificationType.Favourite:
+          return NotificationType.Favourite
+        case FriendicaNotificationType.Mention:
+          return NotificationType.Mention
+        case FriendicaNotificationType.Reblog:
+          return NotificationType.Reblog
+        case FriendicaNotificationType.FollowRequest:
+          return NotificationType.FollowRequest
+        case FriendicaNotificationType.Status:
+          return NotificationType.Status
+        case FriendicaNotificationType.Poll:
+          return NotificationType.PollExpired
+        case FriendicaNotificationType.Update:
+          return NotificationType.Update
+        default:
+          return new UnknownNotificationTypeError()
+      }
+    }
+
+    export const account = (a: Entity.Account): MegalodonEntity.Account => ({
+      id: a.id,
+      username: a.username,
+      acct: a.acct,
+      display_name: a.display_name,
+      locked: a.locked,
+      discoverable: a.discoverable,
+      group: a.group,
+      noindex: null,
+      suspended: null,
+      limited: null,
+      created_at: a.created_at,
+      followers_count: a.followers_count,
+      following_count: a.following_count,
+      statuses_count: a.statuses_count,
+      note: a.note,
+      url: a.url,
+      avatar: a.avatar,
+      avatar_static: a.avatar_static,
+      header: a.header,
+      header_static: a.header_static,
+      emojis: a.emojis.map(e => emoji(e)),
+      moved: a.moved ? account(a.moved) : null,
+      fields: a.fields.map(f => field(f)),
+      bot: a.bot,
+      source: a.source ? source(a.source) : undefined
+    })
+    export const activity = (a: Entity.Activity): MegalodonEntity.Activity => a
+    export const application = (a: Entity.Application): MegalodonEntity.Application => a
+    export const attachment = (a: Entity.Attachment): MegalodonEntity.Attachment => a
+    export const async_attachment = (a: Entity.AsyncAttachment) => {
+      if (a.url) {
+        return {
+          id: a.id,
+          type: a.type,
+          url: a.url,
+          remote_url: a.remote_url,
+          preview_url: a.preview_url,
+          text_url: a.text_url,
+          meta: a.meta,
+          description: a.description,
+          blurhash: a.blurhash
+        } as MegalodonEntity.Attachment
+      } else {
+        return a as MegalodonEntity.AsyncAttachment
+      }
+    }
+    export const card = (c: Entity.Card): MegalodonEntity.Card => ({
+      url: c.url,
+      title: c.title,
+      description: c.description,
+      type: c.type,
+      image: c.image,
+      author_name: c.author_name,
+      author_url: c.author_url,
+      provider_name: c.provider_name,
+      provider_url: c.provider_url,
+      html: c.html,
+      width: c.width,
+      height: c.height,
+      embed_url: null,
+      blurhash: c.blurhash
+    })
+    export const context = (c: Entity.Context): MegalodonEntity.Context => ({
+      ancestors: Array.isArray(c.ancestors) ? c.ancestors.map(a => status(a)) : [],
+      descendants: Array.isArray(c.descendants) ? c.descendants.map(d => status(d)) : []
+    })
+    export const conversation = (c: Entity.Conversation): MegalodonEntity.Conversation => ({
+      id: c.id,
+      accounts: Array.isArray(c.accounts) ? c.accounts.map(a => account(a)) : [],
+      last_status: c.last_status ? status(c.last_status) : null,
+      unread: c.unread
+    })
+    export const emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => ({
+      shortcode: e.shortcode,
+      static_url: e.static_url,
+      url: e.url,
+      visible_in_picker: e.visible_in_picker
+    })
+    export const featured_tag = (e: Entity.FeaturedTag): MegalodonEntity.FeaturedTag => e
+    export const field = (f: Entity.Field): MegalodonEntity.Field => f
+    export const filter = (f: Entity.Filter): MegalodonEntity.Filter => f
+    export const follow_request = (f: Entity.FollowRequest): MegalodonEntity.FollowRequest => ({
+      id: f.id,
+      username: f.username,
+      acct: f.acct,
+      display_name: f.display_name,
+      locked: f.locked,
+      bot: f.bot,
+      discoverable: f.discoverable,
+      group: f.group,
+      created_at: f.created_at,
+      note: f.note,
+      url: f.url,
+      avatar: f.avatar,
+      avatar_static: f.avatar_static,
+      header: f.header,
+      header_static: f.header_static,
+      followers_count: f.followers_count,
+      following_count: f.following_count,
+      statuses_count: f.statuses_count,
+      emojis: f.emojis.map(e => emoji(e)),
+      fields: f.fields.map(f => field(f))
+    })
+    export const history = (h: Entity.History): MegalodonEntity.History => h
+    export const identity_proof = (i: Entity.IdentityProof): MegalodonEntity.IdentityProof => i
+    export const instance = (i: Entity.Instance): MegalodonEntity.Instance => {
+      return {
+        uri: i.uri,
+        title: i.title,
+        description: i.description,
+        email: i.email,
+        version: i.version,
+        thumbnail: i.thumbnail,
+        urls: i.urls ? urls(i.urls) : null,
+        stats: stats(i.stats),
+        languages: i.languages,
+        registrations: i.registrations,
+        approval_required: i.approval_required,
+        invites_enabled: i.invites_enabled,
+        configuration: {
+          statuses: {
+            max_characters: i.max_toot_chars
+          }
+        },
+        contact_account: account(i.contact_account),
+        rules: i.rules
+      }
+    }
+    export const list = (l: Entity.List): MegalodonEntity.List => l
+    export const marker = (m: Entity.Marker): MegalodonEntity.Marker => m
+    export const mention = (m: Entity.Mention): MegalodonEntity.Mention => m
+    export const notification = (n: Entity.Notification): MegalodonEntity.Notification | UnknownNotificationTypeError => {
+      const notificationType = decodeNotificationType(n.type)
+      if (notificationType instanceof UnknownNotificationTypeError) return notificationType
+      if (n.status) {
+        return {
+          account: account(n.account),
+          created_at: n.created_at,
+          id: n.id,
+          status: status(n.status),
+          type: notificationType
+        }
+      } else {
+        return {
+          account: account(n.account),
+          created_at: n.created_at,
+          id: n.id,
+          type: notificationType
+        }
+      }
+    }
+    export const poll = (p: Entity.Poll): MegalodonEntity.Poll => p
+    export const poll_option = (p: Entity.PollOption): MegalodonEntity.PollOption => p
+    export const preferences = (p: Entity.Preferences): MegalodonEntity.Preferences => p
+    export const push_subscription = (p: Entity.PushSubscription): MegalodonEntity.PushSubscription => p
+    export const relationship = (r: Entity.Relationship): MegalodonEntity.Relationship => r
+    export const report = (r: Entity.Report): MegalodonEntity.Report => ({
+      id: r.id,
+      action_taken: r.action_taken,
+      action_taken_at: null,
+      category: r.category,
+      comment: r.comment,
+      forwarded: r.forwarded,
+      status_ids: r.status_ids,
+      rule_ids: r.rule_ids,
+      target_account: account(r.target_account)
+    })
+    export const results = (r: Entity.Results): MegalodonEntity.Results => ({
+      accounts: Array.isArray(r.accounts) ? r.accounts.map(a => account(a)) : [],
+      statuses: Array.isArray(r.statuses) ? r.statuses.map(s => status(s)) : [],
+      hashtags: Array.isArray(r.hashtags) ? r.hashtags.map(h => tag(h)) : []
+    })
+    export const scheduled_status = (s: Entity.ScheduledStatus): MegalodonEntity.ScheduledStatus => {
+      return {
+        id: s.id,
+        scheduled_at: s.scheduled_at,
+        params: status_params(s.params),
+        media_attachments: s.media_attachments ? s.media_attachments.map(a => attachment(a)) : null
+      }
+    }
+    export const source = (s: Entity.Source): MegalodonEntity.Source => s
+    export const stats = (s: Entity.Stats): MegalodonEntity.Stats => s
+    export const status = (s: Entity.Status): MegalodonEntity.Status => ({
+      id: s.id,
+      uri: s.uri,
+      url: s.url,
+      account: account(s.account),
+      in_reply_to_id: s.in_reply_to_id,
+      in_reply_to_account_id: s.in_reply_to_account_id,
+      reblog: s.reblog ? status(s.reblog) : s.quote ? status(s.quote) : null,
+      content: s.content,
+      plain_content: null,
+      created_at: s.created_at,
+      emojis: Array.isArray(s.emojis) ? s.emojis.map(e => emoji(e)) : [],
+      replies_count: s.replies_count,
+      reblogs_count: s.reblogs_count,
+      favourites_count: s.favourites_count,
+      reblogged: s.reblogged,
+      favourited: s.favourited,
+      muted: s.muted,
+      sensitive: s.sensitive,
+      spoiler_text: s.spoiler_text,
+      visibility: s.visibility,
+      media_attachments: Array.isArray(s.media_attachments) ? s.media_attachments.map(m => attachment(m)) : [],
+      mentions: Array.isArray(s.mentions) ? s.mentions.map(m => mention(m)) : [],
+      tags: s.tags,
+      card: s.card ? card(s.card) : null,
+      poll: s.poll ? poll(s.poll) : null,
+      application: s.application ? application(s.application) : null,
+      language: s.language,
+      pinned: s.pinned,
+      emoji_reactions: [],
+      bookmarked: s.bookmarked ? s.bookmarked : false,
+      quote: false
+    })
+    export const status_params = (s: Entity.StatusParams): MegalodonEntity.StatusParams => {
+      return {
+        text: s.text,
+        in_reply_to_id: s.in_reply_to_id,
+        media_ids: s.media_ids,
+        sensitive: s.sensitive,
+        spoiler_text: s.spoiler_text,
+        visibility: s.visibility,
+        scheduled_at: s.scheduled_at,
+        application_id: parseInt(s.application_id)
+      }
+    }
+    export const status_source = (s: Entity.StatusSource): MegalodonEntity.StatusSource => s
+    export const tag = (t: Entity.Tag): MegalodonEntity.Tag => t
+    export const token = (t: Entity.Token): MegalodonEntity.Token => t
+    export const urls = (u: Entity.URLs): MegalodonEntity.URLs => u
+  }
+}
+export default FriendicaAPI

packages/megalodon/src/friendica/entities/account.ts

@@ -0,0 +1,29 @@
+/// <reference path="emoji.ts" />
+/// <reference path="source.ts" />
+/// <reference path="field.ts" />
+namespace FriendicaEntity {
+  export type Account = {
+    id: string
+    username: string
+    acct: string
+    display_name: string
+    locked: boolean
+    discoverable?: boolean
+    group: boolean | null
+    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
+    source?: Source
+  }
+}

packages/megalodon/src/friendica/entities/activity.ts

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

packages/megalodon/src/friendica/entities/application.ts

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

packages/megalodon/src/friendica/entities/async_attachment.ts

@@ -0,0 +1,14 @@
+/// <reference path="attachment.ts" />
+namespace FriendicaEntity {
+  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/friendica/entities/attachment.ts

@@ -0,0 +1,49 @@
+namespace FriendicaEntity {
+  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/friendica/entities/card.ts

@@ -0,0 +1,17 @@
+namespace FriendicaEntity {
+  export type Card = {
+    url: string
+    title: string
+    description: string
+    type: 'link' | 'photo' | 'video' | 'rich'
+    image: string | null
+    author_name: string
+    author_url: string
+    provider_name: string
+    provider_url: string
+    html: string
+    width: number
+    height: number
+    blurhash: string | null
+  }
+}

packages/megalodon/src/friendica/entities/context.ts

@@ -0,0 +1,8 @@
+/// <reference path="status.ts" />
+
+namespace FriendicaEntity {
+  export type Context = {
+    ancestors: Array<Status>
+    descendants: Array<Status>
+  }
+}

packages/megalodon/src/friendica/entities/conversation.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+
+namespace FriendicaEntity {
+  export type Conversation = {
+    id: string
+    accounts: Array<Account>
+    last_status: Status | null
+    unread: boolean
+  }
+}

packages/megalodon/src/friendica/entities/emoji.ts

@@ -0,0 +1,8 @@
+namespace FriendicaEntity {
+  export type Emoji = {
+    shortcode: string
+    static_url: string
+    url: string
+    visible_in_picker: boolean
+  }
+}

packages/megalodon/src/friendica/entities/featured_tag.ts

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

packages/megalodon/src/friendica/entities/field.ts

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

packages/megalodon/src/friendica/entities/filter.ts

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

packages/megalodon/src/friendica/entities/follow_request.ts

@@ -0,0 +1,27 @@
+/// <reference path="emoji.ts" />
+/// <reference path="field.ts" />
+
+namespace FriendicaEntity {
+  export type FollowRequest = {
+    id: number
+    username: string
+    acct: string
+    display_name: string
+    locked: boolean
+    bot: boolean
+    discoverable?: boolean
+    group: boolean
+    created_at: string
+    note: string
+    url: string
+    avatar: string
+    avatar_static: string
+    header: string
+    header_static: string
+    followers_count: number
+    following_count: number
+    statuses_count: number
+    emojis: Array<Emoji>
+    fields: Array<Field>
+  }
+}

packages/megalodon/src/friendica/entities/history.ts

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

packages/megalodon/src/friendica/entities/identity_proof.ts

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

packages/megalodon/src/friendica/entities/instance.ts

@@ -0,0 +1,28 @@
+/// <reference path="account.ts" />
+/// <reference path="urls.ts" />
+/// <reference path="stats.ts" />
+
+namespace FriendicaEntity {
+  export type Instance = {
+    uri: string
+    title: string
+    description: string
+    email: string
+    version: string
+    thumbnail: string | null
+    urls: URLs | null
+    stats: Stats
+    languages: Array<string>
+    registrations: boolean
+    approval_required: boolean
+    invites_enabled: boolean
+    max_toot_chars: number
+    contact_account: Account
+    rules: Array<InstanceRule>
+  }
+
+  export type InstanceRule = {
+    id: string
+    text: string
+  }
+}

packages/megalodon/src/friendica/entities/list.ts

@@ -0,0 +1,9 @@
+namespace FriendicaEntity {
+  export type List = {
+    id: string
+    title: string
+    replies_policy: RepliesPolicy
+  }
+
+  export type RepliesPolicy = 'followed' | 'list' | 'none'
+}

packages/megalodon/src/friendica/entities/marker.ts

@@ -0,0 +1,14 @@
+namespace FriendicaEntity {
+  export type Marker = {
+    home: {
+      last_read_id: string
+      version: number
+      updated_at: string
+    }
+    notifications: {
+      last_read_id: string
+      version: number
+      updated_at: string
+    }
+  }
+}

packages/megalodon/src/friendica/entities/mention.ts

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

packages/megalodon/src/friendica/entities/notification.ts

@@ -0,0 +1,14 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+
+namespace FriendicaEntity {
+  export type Notification = {
+    account: Account
+    created_at: string
+    id: string
+    status?: Status
+    type: NotificationType
+  }
+
+  export type NotificationType = string
+}

packages/megalodon/src/friendica/entities/poll.ts

@@ -0,0 +1,13 @@
+/// <reference path="poll_option.ts" />
+
+namespace FriendicaEntity {
+  export type Poll = {
+    id: string
+    expires_at: string | null
+    expired: boolean
+    multiple: boolean
+    votes_count: number
+    options: Array<PollOption>
+    voted: boolean
+  }
+}

packages/megalodon/src/friendica/entities/poll_option.ts

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

packages/megalodon/src/friendica/entities/preferences.ts

@@ -0,0 +1,9 @@
+namespace FriendicaEntity {
+  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
+  }
+}

packages/megalodon/src/friendica/entities/push_subscription.ts

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

packages/megalodon/src/friendica/entities/relationship.ts

@@ -0,0 +1,17 @@
+namespace FriendicaEntity {
+  export type Relationship = {
+    id: string
+    following: boolean
+    followed_by: boolean
+    blocking: boolean
+    blocked_by: boolean
+    muting: boolean
+    muting_notifications: boolean
+    requested: boolean
+    domain_blocking: boolean
+    showing_reblogs: boolean
+    endorsed: boolean
+    notifying: boolean
+    note: string | null
+  }
+}

packages/megalodon/src/friendica/entities/report.ts

@@ -0,0 +1,16 @@
+/// <reference path="account.ts" />
+
+namespace FriendicaEntity {
+  export type Report = {
+    id: string
+    action_taken: boolean
+    category: Category
+    comment: string
+    forwarded: boolean
+    status_ids: Array<string> | null
+    rule_ids: Array<string> | null
+    target_account: Account
+  }
+
+  export type Category = 'spam' | 'violation' | 'other'
+}

packages/megalodon/src/friendica/entities/results.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+/// <reference path="tag.ts" />
+
+namespace FriendicaEntity {
+  export type Results = {
+    accounts: Array<Account>
+    statuses: Array<Status>
+    hashtags: Array<Tag>
+  }
+}

packages/megalodon/src/friendica/entities/scheduled_status.ts

@@ -0,0 +1,10 @@
+/// <reference path="attachment.ts" />
+/// <reference path="status_params.ts" />
+namespace FriendicaEntity {
+  export type ScheduledStatus = {
+    id: string
+    scheduled_at: string
+    params: StatusParams
+    media_attachments: Array<Attachment>
+  }
+}

packages/megalodon/src/friendica/entities/source.ts

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

packages/megalodon/src/friendica/entities/stats.ts

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

packages/megalodon/src/friendica/entities/status.ts

@@ -0,0 +1,48 @@
+/// <reference path="account.ts" />
+/// <reference path="application.ts" />
+/// <reference path="mention.ts" />
+/// <reference path="attachment.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="card.ts" />
+/// <reference path="poll.ts" />
+
+namespace FriendicaEntity {
+  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
+    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<StatusTag>
+    card: Card | null
+    poll: Poll | null
+    application: Application | null
+    language: string | null
+    pinned: boolean | null
+    bookmarked?: boolean
+    // These parameters are unique parameters in fedibird.com for quote.
+    quote_id?: string
+    quote?: Status | null
+  }
+
+  export type StatusTag = {
+    name: string
+    url: string
+  }
+}

packages/megalodon/src/friendica/entities/status_params.ts

@@ -0,0 +1,12 @@
+namespace FriendicaEntity {
+  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' | null
+    scheduled_at: string | null
+    application_id: string
+  }
+}

packages/megalodon/src/friendica/entities/status_source.ts

@@ -0,0 +1,7 @@
+namespace FriendicaEntity {
+  export type StatusSource = {
+    id: string
+    text: string
+    spoiler_text: string
+  }
+}

packages/megalodon/src/friendica/entities/tag.ts

@@ -0,0 +1,10 @@
+/// <reference path="history.ts" />
+
+namespace FriendicaEntity {
+  export type Tag = {
+    name: string
+    url: string
+    history: Array<History>
+    following?: boolean
+  }
+}

packages/megalodon/src/friendica/entities/token.ts

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

packages/megalodon/src/friendica/entities/urls.ts

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

packages/megalodon/src/friendica/entity.ts

@@ -0,0 +1,38 @@
+/// <reference path="./entities/account.ts" />
+/// <reference path="./entities/activity.ts" />
+/// <reference path="./entities/application.ts" />
+/// <reference path="./entities/async_attachment.ts" />
+/// <reference path="./entities/attachment.ts" />
+/// <reference path="./entities/card.ts" />
+/// <reference path="./entities/context.ts" />
+/// <reference path="./entities/conversation.ts" />
+/// <reference path="./entities/emoji.ts" />
+/// <reference path="./entities/featured_tag.ts" />
+/// <reference path="./entities/field.ts" />
+/// <reference path="./entities/filter.ts" />
+/// <reference path="./entities/follow_request.ts" />
+/// <reference path="./entities/history.ts" />
+/// <reference path="./entities/identity_proof.ts" />
+/// <reference path="./entities/instance.ts" />
+/// <reference path="./entities/list.ts" />
+/// <reference path="./entities/marker.ts" />
+/// <reference path="./entities/mention.ts" />
+/// <reference path="./entities/notification.ts" />
+/// <reference path="./entities/poll.ts" />
+/// <reference path="./entities/poll_option.ts" />
+/// <reference path="./entities/preferences.ts" />
+/// <reference path="./entities/push_subscription.ts" />
+/// <reference path="./entities/relationship.ts" />
+/// <reference path="./entities/report.ts" />
+/// <reference path="./entities/results.ts" />
+/// <reference path="./entities/scheduled_status.ts" />
+/// <reference path="./entities/source.ts" />
+/// <reference path="./entities/stats.ts" />
+/// <reference path="./entities/status.ts" />
+/// <reference path="./entities/status_params.ts" />
+/// <reference path="./entities/status_source.ts" />
+/// <reference path="./entities/tag.ts" />
+/// <reference path="./entities/token.ts" />
+/// <reference path="./entities/urls.ts" />
+
+export default FriendicaEntity

packages/megalodon/src/friendica/notification.ts

@@ -0,0 +1,14 @@
+import FriendicaEntity from './entity'
+
+namespace FriendicaNotificationType {
+  export const Mention: FriendicaEntity.NotificationType = 'mention'
+  export const Reblog: FriendicaEntity.NotificationType = 'reblog'
+  export const Favourite: FriendicaEntity.NotificationType = 'favourite'
+  export const Follow: FriendicaEntity.NotificationType = 'follow'
+  export const Poll: FriendicaEntity.NotificationType = 'poll'
+  export const FollowRequest: FriendicaEntity.NotificationType = 'follow_request'
+  export const Status: FriendicaEntity.NotificationType = 'status'
+  export const Update: FriendicaEntity.NotificationType = 'update'
+}
+
+export default FriendicaNotificationType

packages/megalodon/src/friendica/web_socket.ts

@@ -0,0 +1,18 @@
+import { WebSocketInterface } from '../megalodon'
+import { EventEmitter } from 'events'
+import { ProxyConfig } from '../proxy_config'
+
+export default class WebSocket extends EventEmitter implements WebSocketInterface {
+  constructor(
+    _url: string,
+    _stream: string,
+    _params: string | undefined,
+    _accessToken: string,
+    _userAgent: string,
+    _proxyConfig: ProxyConfig | false = false
+  ) {
+    super()
+  }
+  public start() {}
+  public stop() {}
+}