@nerimity/nerimity.js 1.15.2 → 1.16.1

package/src/Client.ts

@@ -1,875 +0,0 @@
-import EventEmitter from "eventemitter3";
-import { Socket, io } from "socket.io-client";
-import {
-  ClientEventMap,
-  ClientEvents,
-  SocketClientEvents,
-  SocketServerEvents,
-} from "./EventNames";
-import {
-  AuthenticatedPayload,
-  ChannelType,
-  MessageButtonClickPayload,
-  MessageType,
-  RawBotCommand,
-  RawChannel,
-  RawMessage,
-  RawMessageButton,
-  RawPost,
-  RawServer,
-  RawServerMember,
-  RawServerRole,
-  RawUser,
-} from "./RawData";
-import {
-  ButtonCallback,
-  buttonClickCallback,
-  ButtonClickCallbackOpts,
-  deleteMessage,
-  editMessage,
-  postMessage,
-} from "./services/MessageService";
-import { path, updatePath } from "./services/serviceEndpoints";
-import {
-  deletePost,
-  editPost,
-  getPosts,
-  postPost,
-} from "./services/PostsService";
-import { updateCommands as postUpdateCommands } from "./services/ApplicationService";
-import { banServerMember } from "./services/ServerService";
-import {
-  addBit,
-  AvailablePermissions,
-  hasBit,
-  RolePermissions,
-} from "./bitwise";
-
-export const Events = ClientEvents;
-
-export class Client extends EventEmitter<ClientEventMap> {
-  socket: Socket;
-  token: string | undefined;
-  user: ClientUser | undefined;
-  users: Users;
-  channels: Channels;
-  servers: Servers;
-  posts: Posts;
-
-  constructor(opts?: { urlOverride?: string }) {
-    super();
-    if (opts?.urlOverride) {
-      updatePath(opts.urlOverride);
-    }
-    this.socket = io(path, {
-      transports: ["websocket"],
-      autoConnect: false,
-    });
-    this.channels = new Channels(this);
-    this.users = new Users(this);
-    this.servers = new Servers(this);
-    this.posts = new Posts(this);
-    new EventHandlers(this);
-  }
-
-  updateCommands(token: string, commands: Omit<RawBotCommand, "botUserId">[]) {
-    return postUpdateCommands(token, commands);
-  }
-  public login(token: string) {
-    this.token = token;
-    this.socket.connect();
-  }
-}
-
-class EventHandlers {
-  client: Client;
-  socket: Socket;
-  constructor(client: Client) {
-    this.client = client;
-    this.socket = client.socket;
-
-    client.socket.on(SocketServerEvents.CONNECT, this.onConnect.bind(this));
-    client.socket.on(
-      SocketServerEvents.USER_AUTHENTICATED,
-      this.onAuthenticated.bind(this)
-    );
-
-    client.socket.on(
-      SocketServerEvents.SERVER_MEMBER_JOINED,
-      this.onServerMemberJoined.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_MEMBER_UPDATED,
-      this.onServerMemberUpdated.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_MEMBER_LEFT,
-      this.onServerMemberLeft.bind(this)
-    );
-
-    client.socket.on(
-      SocketServerEvents.SERVER_JOINED,
-      this.onServerJoined.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_CHANNEL_CREATED,
-      this.onServerChannelCreated.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_CHANNEL_UPDATED,
-      this.onServerChannelUpdated.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_CHANNEL_DELETED,
-      this.onServerChannelDeleted.bind(this)
-    );
-
-    client.socket.on(
-      SocketServerEvents.SERVER_LEFT,
-      this.onServerLeft.bind(this)
-    );
-
-    client.socket.on(
-      SocketServerEvents.MESSAGE_CREATED,
-      this.onMessageCreated.bind(this)
-    );
-
-    client.socket.on(
-      SocketServerEvents.MESSAGE_BUTTON_CLICKED,
-      this.onMessageButtonClicked.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_ROLE_CREATED,
-      this.onServerRoleCreated.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_ROLE_DELETED,
-      this.onServerRoleDeleted.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_ROLE_UPDATED,
-      this.onServerRoleUpdated.bind(this)
-    );
-    client.socket.on(
-      SocketServerEvents.SERVER_ROLE_ORDER_UPDATED,
-      this.onServerRoleOrderUpdated.bind(this)
-    );
-  }
-  onConnect() {
-    this.socket.emit(SocketClientEvents.AUTHENTICATE, {
-      token: this.client.token,
-    });
-  }
-  onAuthenticated(payload: AuthenticatedPayload) {
-    this.client.user = new ClientUser(this.client, payload.user);
-
-    for (let i = 0; i < payload.servers.length; i++) {
-      const server = payload.servers[i];
-      this.client.servers.setCache(server);
-    }
-
-    for (let i = 0; i < payload.channels.length; i++) {
-      const rawChannel = payload.channels[i];
-      this.client.channels.setCache(rawChannel);
-    }
-    for (let i = 0; i < payload.serverMembers.length; i++) {
-      const member = payload.serverMembers[i];
-      this.client.users.setCache(member.user);
-      const server = this.client.servers.cache.get(member.serverId);
-      server?.members.setCache(member);
-    }
-
-    for (let i = 0; i < payload.serverRoles.length; i++) {
-      const role = payload.serverRoles[i];
-      const server = this.client.servers.cache.get(role.serverId);
-      server?.roles.setCache(role);
-    }
-
-    this.client.emit(ClientEvents.Ready);
-  }
-
-  onServerMemberJoined(payload: { serverId: string; member: RawServerMember }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    this.client.users.setCache(payload.member.user);
-    const member = server?.members.setCache(payload.member);
-    if (!member) return;
-    this.client.emit(ClientEvents.ServerMemberJoined, member);
-  }
-
-  onServerMemberUpdated(payload: {
-    serverId: string;
-    userId: string;
-    updated: {
-      roleIds: string[];
-    };
-  }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    const member = server?.members.cache.get(payload.userId);
-    if (!member) return;
-
-    updateClass<ServerMember>(member, payload.updated);
-
-    this.client.emit(ClientEvents.ServerMemberUpdated, member);
-  }
-
-  onServerJoined(payload: {
-    server: RawServer;
-    members: RawServerMember[];
-    channels: RawChannel[];
-    roles: RawServerRole[];
-    // memberPresences: any[]
-    // voiceChannelUsers: any[];
-  }) {
-    const server = this.client.servers.setCache(payload.server);
-
-    for (let i = 0; i < payload.members.length; i++) {
-      const member = payload.members[i];
-      this.client.users.setCache(member.user);
-      server?.members.setCache(member);
-    }
-    for (let i = 0; i < payload.roles.length; i++) {
-      const role = payload.roles[i];
-      server?.roles.setCache(role);
-    }
-
-    for (let i = 0; i < payload.channels.length; i++) {
-      const channel = payload.channels[i];
-      this.client.channels.setCache(channel);
-    }
-    this.client.emit(ClientEvents.ServerJoined, server);
-  }
-  onServerChannelCreated(payload: { serverId: string; channel: RawChannel }) {
-    const channel = this.client.channels.setCache(payload.channel);
-    this.client.emit(
-      ClientEvents.ServerChannelCreated,
-      channel as ServerChannel
-    );
-  }
-  onServerChannelUpdated(payload: {
-    serverId: string;
-    channelId: string;
-    updated: Partial<RawChannel>;
-  }) {
-    const channel = this.client.channels.cache.get(payload.channelId);
-    const updated = payload.updated;
-    if (channel) {
-      updateClass<ServerChannel>(channel as ServerChannel, updated);
-      this.client.emit(
-        ClientEvents.ServerChannelUpdated,
-        channel as ServerChannel
-      );
-    }
-  }
-  onServerChannelDeleted(payload: { serverId: string; channelId: string }) {
-    const channel = this.client.channels.cache.has(payload.channelId);
-    if (channel) {
-      this.client.channels.cache.delete(payload.channelId);
-      this.client.emit(ClientEvents.ServerChannelDeleted, {
-        channelId: payload.channelId,
-        serverId: payload.serverId,
-      });
-    }
-  }
-  onServerLeft(payload: { serverId: string }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    if (!server) return;
-    this.client.emit(ClientEvents.ServerLeft, server);
-    this.client.servers.cache.delete(payload.serverId);
-
-    this.client.channels.cache.forEach((channel) => {
-      if (
-        channel instanceof ServerChannel &&
-        channel.serverId === payload.serverId
-      ) {
-        this.client.channels.cache.delete(channel.id);
-      }
-    });
-    server.members.cache.clear();
-  }
-  onServerMemberLeft(payload: { userId: string; serverId: string }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    const member = server?.members.cache.get(payload.userId);
-    if (!member) return;
-    this.client.emit(ClientEvents.ServerMemberLeft, member);
-    server?.members.cache.delete(payload.userId);
-  }
-  onMessageCreated(payload: { message: RawMessage }) {
-    const message = new Message(this.client, payload.message);
-    this.client.emit(ClientEvents.MessageCreate, message);
-  }
-  onMessageButtonClicked(payload: MessageButtonClickPayload) {
-    const button = new Button(this.client, payload);
-    this.client.emit(ClientEvents.MessageButtonClick, button);
-  }
-  onServerRoleCreated(payload: RawServerRole) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    const role = server?.roles.setCache(payload);
-    if (!role) return;
-    this.client.emit(ClientEvents.ServerRoleCreated, role);
-  }
-  onServerRoleDeleted(payload: { serverId: string; roleId: string }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    const role = server?.roles.cache.get(payload.roleId);
-    if (!role) return;
-    server?.roles.cache.delete(payload.roleId);
-
-    this.client.emit(ClientEvents.ServerRoleDeleted, role);
-  }
-  onServerRoleUpdated(payload: {
-    serverId: string;
-    roleId: string;
-    updated: Partial<RawServerRole>;
-  }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-    const role = server?.roles.cache.get(payload.roleId);
-    if (!role) return;
-
-    updateClass<ServerRole>(role, payload.updated);
-
-    this.client.emit(ClientEvents.ServerRoleUpdated, role);
-  }
-  onServerRoleOrderUpdated(payload: { serverId: string; roleIds: string[] }) {
-    const server = this.client.servers.cache.get(payload.serverId);
-
-    for (let i = 0; i < payload.roleIds.length; i++) {
-      const roleId = payload.roleIds[i];
-      const role = server?.roles.cache.get(roleId);
-      if (!role) continue;
-      role.order = i + 1;
-    }
-
-    this.client.emit(ClientEvents.ServerRoleOrderUpdated, server?.roles!);
-  }
-}
-
-export class Users {
-  client: Client;
-  cache: Collection<string, User>;
-  constructor(client: Client) {
-    this.client = client;
-    this.cache = new Collection();
-  }
-  setCache(rawUser: RawUser) {
-    const user = new User(this.client, rawUser);
-    this.cache.set(rawUser.id, user);
-    return user;
-  }
-}
-
-export class Servers {
-  client: Client;
-  cache: Collection<string, Server>;
-  constructor(client: Client) {
-    this.client = client;
-    this.cache = new Collection();
-  }
-  setCache(rawServer: RawServer) {
-    const server = new Server(this.client, rawServer);
-    this.cache.set(server.id, server);
-    return server;
-  }
-}
-
-export class Server {
-  client: Client;
-  id: string;
-  name: string;
-  avatar?: string;
-  defaultRoleId: string;
-  createdById: string;
-
-  members: ServerMembers;
-  roles: ServerRoles;
-  constructor(client: Client, server: RawServer) {
-    this.client = client;
-
-    this.id = server.id;
-    this.name = server.name;
-    this.avatar = server.avatar;
-    this.members = new ServerMembers(this.client);
-    this.roles = new ServerRoles(this.client);
-    this.defaultRoleId = server.defaultRoleId;
-    this.createdById = server.createdById;
-  }
-
-  async banMember(userId: string) {
-    return banServerMember(this.client, this.id, userId);
-  }
-}
-
-export class ServerRoles {
-  client: Client;
-  cache: Collection<string, ServerRole>;
-  constructor(client: Client) {
-    this.client = client;
-    this.cache = new Collection();
-  }
-  setCache(rawServerRole: RawServerRole) {
-    const server = new ServerRole(this.client, rawServerRole);
-    this.cache.set(server.id, server);
-    return server;
-  }
-}
-
-export class ServerRole {
-  client: Client;
-  id: string;
-  name: string;
-  permissions: number;
-  hexColor: string;
-  server: Server;
-  order: number;
-  isDefaultRole?: boolean;
-  constructor(client: Client, role: RawServerRole) {
-    this.client = client;
-    this.server = this.client.servers.cache.get(role.serverId)!;
-
-    this.id = role.id;
-    this.name = role.name;
-    this.permissions = role.permissions;
-    this.hexColor = role.hexColor;
-    this.order = role.order;
-    this.isDefaultRole = this.server.defaultRoleId === this.id;
-  }
-}
-
-export class ServerMembers {
-  client: Client;
-  cache: Collection<string, ServerMember>;
-  constructor(client: Client) {
-    this.client = client;
-    this.cache = new Collection();
-  }
-  setCache(rawMember: RawServerMember) {
-    const member = new ServerMember(this.client, rawMember);
-    this.cache.set(member.user.id, member);
-    return member;
-  }
-}
-export class ServerMember {
-  client: Client;
-  id: string;
-  user: User;
-  server: Server;
-  roleIds: string[];
-  nickname?: string | null;
-
-  constructor(client: Client, member: RawServerMember) {
-    this.client = client;
-    this.id = member.user.id;
-    this.roleIds = member.roleIds;
-    this.nickname = member.nickname;
-
-    this.user = this.client.users.cache.get(member.user.id)!;
-    this.server = this.client.servers.cache.get(member.serverId)!;
-  }
-  toString() {
-    return `[@:${this.id}]`;
-  }
-  async ban() {
-    return banServerMember(this.client, this.server.id, this.user.id);
-  }
-  get roles() {
-    return this.roleIds
-      .map((id) => this.server.roles.cache.get(id)!)
-      .filter(Boolean);
-  }
-
-  permissions(this: ServerMember) {
-    const defaultRoleId = this.server?.defaultRoleId;
-    const defaultRole = this.server.roles.cache.get(defaultRoleId!);
-
-    let currentPermissions = defaultRole?.permissions || 0;
-
-    const memberRoles = this.roles;
-    for (let i = 0; i < memberRoles.length; i++) {
-      const role = memberRoles[i];
-      currentPermissions = addBit(currentPermissions, role?.permissions || 0);
-    }
-
-    return currentPermissions;
-  }
-
-  hasPermission(
-    permission: AvailablePermissions,
-    ignoreAdmin = false,
-    ignoreCreator = false
-  ) {
-    if (!ignoreCreator) {
-      if (this.server.createdById === this.user.id) return true;
-    }
-    if (!ignoreAdmin) {
-      if (hasBit(this.permissions(), RolePermissions.ADMIN)) return true;
-    }
-    return hasBit(this.permissions(), permission);
-  }
-}
-
-export class Channels {
-  client: Client;
-  cache: Collection<string, AllChannel>;
-  constructor(client: Client) {
-    this.client = client;
-    this.cache = new Collection();
-  }
-  setCache(rawChannel: { id: string } & Omit<Partial<RawChannel>, "id">) {
-    let channel: AllChannel;
-    if (rawChannel.serverId)
-      channel = new ServerChannel(this.client, rawChannel as any);
-    else channel = new Channel(this.client, rawChannel as any);
-    this.cache.set(channel.id, channel);
-    return channel;
-  }
-}
-
-export type AllChannel = ServerChannel | Channel;
-
-export interface MessageOpts {
-  htmlEmbed?: string;
-  nerimityCdnFileId?: string;
-  buttons?: RawMessageButton[];
-  silent?: boolean;
-  replyToMessageIds?: string[];
-  mentionReplies?: boolean;
-}
-
-export interface PostOpts {
-  nerimityCdnFileId?: string;
-  poll?: {
-    choices: string[];
-  };
-}
-
-export class Channel {
-  client: Client;
-  id: string;
-
-  type: ChannelType;
-  createdAt?: number;
-  lastMessagedAt?: number;
-  server?: Server;
-  constructor(client: Client, channel: RawChannel) {
-    this.client = client;
-    this.id = channel.id;
-    this.type = channel.type;
-    this.createdAt = channel.createdAt;
-    this.lastMessagedAt = channel.lastMessagedAt;
-    if (channel.serverId)
-      this.server = this.client.servers.cache.get(channel.serverId)!;
-  }
-
-  async send(content: string, opts?: MessageOpts) {
-    const RawMessage = await postMessage({
-      client: this.client,
-      channelId: this.id,
-      content: content,
-      silent: opts?.silent,
-      nerimityCdnFileId: opts?.nerimityCdnFileId,
-      htmlEmbed: opts?.htmlEmbed,
-      buttons: opts?.buttons,
-      replyToMessageIds: opts?.replyToMessageIds,
-      mentionReplies: opts?.mentionReplies,
-    });
-    const message = new Message(this.client, RawMessage);
-    return message;
-  }
-  toString() {
-    return `[#:${this.id}]`;
-  }
-}
-
-function updateClass<T extends object>(classInstance: T, update: Partial<T>) {
-  for (const [key, value] of Object.entries(update) as [
-    keyof T,
-    T[keyof T]
-  ][]) {
-    classInstance[key] = value;
-  }
-}
-
-export class ServerChannel extends Channel {
-  createdById: string;
-  name: string;
-  serverId: string;
-  permissions: number;
-  categoryId?: string;
-  server: Server;
-
-  constructor(client: Client, channel: RawChannel) {
-    super(client, channel);
-    this.name = channel.name;
-    this.permissions = channel.permissions!;
-    this.createdById = channel.createdById!;
-    this.serverId = channel.serverId!;
-    this.categoryId = channel.categoryId!;
-
-    this.server = this.client.servers.cache.get(this.serverId)!;
-  }
-}
-
-const UserMentionRegex = /\[@:([0-9]+)\]/gm;
-const CommandRegex = /^(\/[^:\s]*):(\d+)( .*)?$/m;
-
-export class Message {
-  client: Client;
-  id: string;
-  content?: string;
-  type: MessageType;
-  createdAt: number;
-  channelId: string;
-  channel: AllChannel;
-  user: User;
-  mentions: User[] = [];
-  command?: { name: string; args: string[] };
-  constructor(client: Client, message: RawMessage) {
-    this.client = client;
-
-    this.id = message.id;
-    this.channelId = message.channelId;
-    this.channel = client.channels.cache.get(this.channelId)!;
-    this.content = message.content;
-    this.type = message.type;
-    this.createdAt = message.createdAt;
-    this.user = this.client.users.cache.get(message.createdBy.id)!;
-
-    const cmd = message.content?.match(CommandRegex);
-    if (cmd?.[2] === this.client.user?.id) {
-      this.command = {
-        name: cmd?.[1]!.substring(1)!,
-        args: message.content!.split(" ").slice(1),
-      };
-    }
-
-    if (!this.user) {
-      this.user = this.client.users.setCache(message.createdBy);
-    }
-
-    if (!this.channel) {
-      this.channel = this.client.channels.setCache({
-        id: this.channelId,
-        type: ChannelType.DM_TEXT,
-      });
-    }
-
-    if (this.content) {
-      const mentionIds = [...this.content.matchAll(UserMentionRegex)].map(
-        (exp) => exp[1]
-      );
-      this.mentions = mentionIds
-        .map((id) => this.client.users.cache.get(id)!)
-        .filter((u) => u);
-    }
-  }
-  get member() {
-    return this.channel.server?.members.cache.get(this.user.id);
-  }
-  reply(content: string, opts?: MessageOpts) {
-    let fOpts: MessageOpts = opts || {};
-    fOpts.replyToMessageIds = [this.id];
-    return this.channel.send(content, opts);
-  }
-  async edit(content: string) {
-    const RawMessage = await editMessage({
-      client: this.client,
-      channelId: this.channel.id,
-      messageId: this.id,
-      content: content,
-    });
-    const message = new Message(this.client, RawMessage);
-    return message;
-  }
-  async delete() {
-    return deleteMessage({
-      channelId: this.channel.id,
-      client: this.client,
-      messageId: this.id,
-    });
-  }
-  toString() {
-    return `[q:${this.id}]`;
-  }
-}
-
-class Posts {
-  client: Client;
-  constructor(client: Client) {
-    this.client = client;
-  }
-
-  async get(id?: string) {
-    const RawPosts = await getPosts(this.client);
-    const posts = RawPosts.map((post) => new Post(this.client, post));
-    return id ? posts.find((p) => p.id === id) : posts;
-  }
-
-  async create(content: string, opts?: PostOpts) {
-    const RawPost = await postPost({
-      client: this.client,
-      content: content,
-      nerimityCdnFileId: opts?.nerimityCdnFileId,
-      poll: opts?.poll,
-    });
-
-    const post = new Post(this.client, RawPost);
-
-    return post;
-  }
-}
-
-export class Post {
-  client: Client;
-  id: string;
-  content?: string;
-  attachments?: Array<any>;
-  deleted: boolean;
-  block?: boolean;
-  commentToId: string;
-  commentTo?: RawPost;
-  createdBy: RawUser;
-  createdAt: number;
-  editedAt: number;
-  likedBy: { id: string }[]; // if you liked this post, array will not be empty
-  reposts: { id: string; createdBy: { id: string; username: string } }[];
-  repost?: RawPost;
-  _count: { likedBy: number; comments: number; reposts: number };
-  views: number;
-  announcement: any;
-  poll?: any;
-
-  constructor(client: Client, post: RawPost) {
-    this.client = client;
-    this.id = post.id;
-    this.content = post.content;
-    this.attachments = post.attachments;
-    this.deleted = post.deleted;
-    this.block = post.block;
-    this.commentToId = post.commentToId;
-    this.commentTo = post.commentTo;
-    this.createdBy = post.createdBy;
-    this.createdAt = post.createdAt;
-    this.editedAt = post.editedAt;
-    this.likedBy = post.likedBy;
-    this.reposts = post.reposts;
-    this.repost = post.repost;
-    this._count = post._count;
-    this.views = post.views;
-    this.announcement = post.announcement;
-    this.poll = post.poll;
-  }
-
-  async edit(content: string) {
-    const RawPost = await editPost({
-      client: this.client,
-      content: content,
-      postId: this.id,
-    });
-
-    const post = new Post(this.client, RawPost);
-    return post;
-  }
-
-  async delete() {
-    await deletePost({
-      client: this.client,
-      postId: this.id,
-    });
-  }
-}
-
-class User {
-  client: Client;
-  id: string;
-  avatar?: string;
-  banner?: string;
-  username: string;
-  hexColor: string;
-  tag: string;
-  badges: number;
-  joinedAt?: number;
-  bot?: boolean;
-  constructor(client: Client, user: RawUser) {
-    this.client = client;
-
-    this.id = user.id;
-    this.username = user.username;
-    this.tag = user.tag;
-
-    this.hexColor = user.hexColor;
-    this.badges = user.badges;
-    this.joinedAt = user.joinedAt;
-    this.avatar = user.avatar;
-    this.banner = user.banner;
-    this.bot = user.bot;
-  }
-  toString() {
-    return `[@:${this.id}]`;
-  }
-}
-
-export interface ActivityOpts {
-  action: string;
-  name: string;
-  startedAt: number;
-  endsAt?: number;
-
-  imgSrc?: string;
-  title?: string;
-  subtitle?: string;
-  link?: string;
-}
-
-class ClientUser extends User {
-  setActivity(activity?: ActivityOpts | null) {
-    this.client.socket.emit(SocketClientEvents.UPDATE_ACTIVITY, activity);
-  }
-
-  constructor(client: Client, user: RawUser) {
-    super(client, user);
-  }
-}
-
-class Collection<K, V> extends Map<K, V> {
-  constructor() {
-    super();
-  }
-}
-
-export class Button {
-  client: Client;
-  id: string;
-
-  userId: string;
-  messageId: string;
-  channelId: string;
-
-  user?: User;
-  channel: Channel;
-
-  data?: Record<string, string>;
-  type: "modal_click" | "button_click";
-
-  constructor(client: Client, payload: MessageButtonClickPayload) {
-    this.client = client;
-
-    this.id = payload.buttonId;
-    this.userId = payload.userId;
-    this.channelId = payload.channelId;
-    this.messageId = payload.messageId;
-    this.user = this.client.users.cache.get(this.userId);
-
-    this.channel = client.channels.cache.get(this.channelId)!;
-    this.data = payload.data;
-    this.type = payload.type;
-  }
-
-  async respond(opts?: ButtonCallback) {
-    await buttonClickCallback({
-      client: this.client,
-      buttonId: this.id,
-      channelId: this.channelId,
-      messageId: this.messageId,
-      userId: this.userId,
-      data: opts,
-    });
-  }
-}