123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518
// deno-lint-ignore-file no-explicit-anyimport type { ActivityType, GatewayActivityButton } from "../../deps.ts";import { CertifiedDevice } from "./CertifiedDevice.ts";import { VoiceSettings } from "./VoiceSettings.ts";import { Lobby, type LobbyType } from "./Lobby.ts";import { Channel } from "./Channel.ts";import { Guild } from "./Guild.ts";import { User } from "./User.ts";
export enum ActivitySupportedPlatform {  IOS = "ios",  ANDROID = "android",  WEB = "web",}
export enum ActivityPartyPrivacy {  PRIVATE = 0,  PUBLIC = 1,}
export type SetActivity = {  /**   * Minimum of 2 characters and maximum of 128 characters   */  state?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  details?: string;  startTimestamp?: number | Date;  endTimestamp?: number | Date;  /**   * Minimum of 1 characters and maximum of 128 characters   */  largeImageKey?: string;  /**   * Minimum of 1 characters and maximum of 128 characters   */  smallImageKey?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  largeImageText?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  smallImageText?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  partyId?: string;  /**   * Default: ActivityPartyPrivacy.PRIVATE   */  partyPrivacy?: ActivityPartyPrivacy;  partySize?: number;  partyMax?: number;  /**   * Minimum of 2 characters and maximum of 128 characters   */  matchSecret?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  joinSecret?: string;  /**   * Minimum of 2 characters and maximum of 128 characters   */  spectateSecret?: string;  instance?: boolean;  buttons?: Array<GatewayActivityButton>;  supportedPlatforms?: (    | ActivitySupportedPlatform    | `${ActivitySupportedPlatform}`  )[];  /**   * Default: ActivityTypes.PLAYING   */  type?:    | ActivityType.Playing    | ActivityType.Listening    | ActivityType.Watching;};
export type SetActivityResponse = {  state?: string;  buttons?: string[];  name: string;  application_id: string;  type: number;  metadata: {    button_urls?: string[];  };};
export class ClientUser extends User {  // #region Helper function
  async fetchUser(userId: string): Promise<User> {    return new User(      this.client,      (await this.client.request("GET_USER", { id: userId })).data,    );  }
  /**   * Used to get a guild the client is in.   *   * @param guildId - id of the guild to get   * @param timeout - asynchronously get guild with time to wait before timing out   * @returns partial guild   */  async fetchGuild(guildId: string, timeout?: number): Promise<Guild> {    return new Guild(      this.client,      (        await this.client.request("GET_GUILD", {          guild_id: guildId,          timeout,        })      ).data,    );  }
  /**   * Used to get a list of guilds the client is in.   * @returns the guilds the user is in   */  async fetchGuilds(): Promise<Guild[]> {    return (await this.client.request("GET_GUILDS")).data.guilds.map(      (guildData: any) => new Guild(this.client, guildData),    );  }
  /**   * Used to get a channel the client is in.   * @param channelId - id of the channel to get   * @returns partial channel   */  async fetchChannel(channelId: string): Promise<Channel> {    return new Channel(      this.client,      (        await this.client.request("GET_CHANNEL", {          channel_id: channelId,        })      ).data,    );  }
  /**   * Used to get a guild's channels the client is in.   * @param guildId - id of the guild to get channels for   * @returns guild channels the user is in   */  async fetchChannels(guildId: string): Promise<Channel> {    return (      await this.client.request("GET_CHANNELS", { guild_id: guildId })    ).data.channels.map(      (channelData: any) => new Channel(this.client, channelData),    );  }
  /**   * Used to get the client's current voice channel. There are no arguments for this command. Returns the [Get Channel](https://discord.com/developers/docs/topics/rpc#getchannel) response, or `null` if none.   * @returns the client's current voice channel, `null` if none   */  async getSelectedVoiceChannel(): Promise<Channel | null> {    const response = await this.client.request("GET_SELECTED_VOICE_CHANNEL");    return response.data !== null      ? new Channel(this.client, response.data)      : null;  }
  /**   * Used to join voice channels, group dms, or dms. Returns the [Get Channel](https://discord.com/developers/docs/topics/rpc#getchannel) response, `null` if none.   * @param channelId - channel id to join   * @param timeout - asynchronously join channel with time to wait before timing out   * @param force - forces a user to join a voice channel   * @returns the channel that the user joined, `null` if none   */  async selectVoiceChannel(    channelId: string,    timeout?: number,    force?: boolean,  ): Promise<Channel> {    return new Channel(      this.client,      (        await this.client.request("SELECT_VOICE_CHANNEL", {          channel_id: channelId,          timeout,          force,        })      ).data,    );  }
  /**   * Used to leave voice channels, group dms, or dms   * @param timeout - asynchronously join channel with time to wait before timing out   * @param force - forces a user to join a voice channel   */  async leaveVoiceChannel(timeout?: number, force?: boolean): Promise<void> {    await this.client.request("SELECT_VOICE_CHANNEL", {      channel_id: null,      timeout,      force,    });  }
  /**   * Used to get current client's voice settings   * @returns the voice setting   */  async getVoiceSettings(): Promise<VoiceSettings> {    return new VoiceSettings(      this.client,      (await this.client.request("GET_VOICE_SETTINGS")).data,    );  }
  /**   * Used to change voice settings of users in voice channels   * @param voiceSettings - the settings   * @returns the settings that have been set   */  async setVoiceSettings(    voiceSettings: Partial<VoiceSettings>,  ): Promise<VoiceSettings> {    return new VoiceSettings(      this.client,      (await this.client.request("SET_VOICE_SETTINGS", voiceSettings)).data,    );  }
  /**   * Used by hardware manufacturers to send information about the current state of their certified devices that are connected to Discord.   * @param devices - a list of devices for your manufacturer, in order of priority   * @returns   */  async setCeritfiedDevices(devices: CertifiedDevice[]): Promise<void> {    await this.client.request("SET_CERTIFIED_DEVICES", { devices });  }
  /**   * Used to accept an Ask to Join request.   * @param userId - the id of the requesting user   */  async sendJoinInvite(userId: string): Promise<void> {    await this.client.request("SEND_ACTIVITY_JOIN_INVITE", {      user_id: userId,    });  }
  /**   * Used to reject an Ask to Join request.   * @param userId - the id of the requesting user   */  async closeJoinRequest(userId: string): Promise<void> {    await this.client.request("CLOSE_ACTIVITY_JOIN_REQUEST", {      user_id: userId,    });  }
  /**   * Used to join text channels, group dms, or dms. Returns the [Get Channel](https://discord.com/developers/docs/topics/rpc#getchannel) response, or `null` if none.   * @param channelId - channel id to join   * @param timeout - asynchronously join channel with time to wait before timing out   * @returns the text channel that user joined   */  async selectTextChannel(    channelId: string,    timeout?: number,  ): Promise<Channel | null> {    return new Channel(      this.client,      (        await this.client.request("SELECT_TEXT_CHANNEL", {          channel_id: channelId,          timeout,        })      ).data,    );  }
  /**   * Used to leave text channels, group dms, or dms.   * @param timeout - asynchronously join channel with time to wait before timing out   */  async leaveTextChannel(timeout?: number): Promise<void> {    await this.client.request("SELECT_TEXT_CHANNEL", {      channel_id: null,      timeout,    });  }
  async getRelationships(): Promise<Array<User>> {    return (      await this.client.request("GET_RELATIONSHIPS")    ).data.relationships.map((data: any) => {      return new User(this.client, { ...data.user, presence: data.presence });    });  }
  /**   * Used to update a user's Rich Presence.   *   * @param activity - the rich presence to assign to the user   * @param pid - the application's process id   * @returns The activity that have been set   */  async setActivity(    activity: SetActivity,    pid?: number,  ): Promise<SetActivityResponse> {    const formattedAcitivity: any = {      ...activity,      assets: {},      timestamps: {},      party: {},      secrets: {},    };
    if (activity.startTimestamp instanceof Date) {      formattedAcitivity.timestamps.start = Math.round(        activity.startTimestamp.getTime(),      );    } else if (typeof activity.startTimestamp === "number") {      formattedAcitivity.timestamps.start = activity.startTimestamp;    }
    if (activity.endTimestamp instanceof Date) {      formattedAcitivity.timestamps.end = Math.round(        activity.endTimestamp.getTime(),      );    } else if (typeof activity.endTimestamp === "number") {      formattedAcitivity.timestamps.end = activity.endTimestamp;    }
    if (activity.largeImageKey) {      formattedAcitivity.assets.large_image = activity.largeImageKey;    }    if (activity.smallImageKey) {      formattedAcitivity.assets.small_image = activity.smallImageKey;    }    if (activity.largeImageText) {      formattedAcitivity.assets.large_text = activity.largeImageText;    }    if (activity.smallImageText) {      formattedAcitivity.assets.small_text = activity.smallImageText;    }
    if (activity.partyId) formattedAcitivity.party.id = activity.partyId;    if (activity.partyPrivacy) {      formattedAcitivity.party.privacy = activity.partyPrivacy;    }    if (activity.partySize && activity.partyMax) {      formattedAcitivity.party.size = [activity.partySize, activity.partyMax];    }
    if (activity.joinSecret) {      formattedAcitivity.secrets.join = activity.joinSecret;    }    if (activity.spectateSecret) {      formattedAcitivity.secrets.spectate = activity.spectateSecret;    }    if (activity.matchSecret) {      formattedAcitivity.secrets.match = activity.matchSecret;    }
    if (activity.supportedPlatforms) {      formattedAcitivity.supported_platforms = activity.supportedPlatforms;    }
    if (Object.keys(formattedAcitivity.assets).length === 0) {      delete formattedAcitivity["assets"];    }    if (Object.keys(formattedAcitivity.timestamps).length === 0) {      delete formattedAcitivity["timestamps"];    }    if (Object.keys(formattedAcitivity.party).length === 0) {      delete formattedAcitivity["party"];    }    if (Object.keys(formattedAcitivity.secrets).length === 0) {      delete formattedAcitivity["secrets"];    }
    formattedAcitivity.instance = !!activity.instance;
    // Clean-up    delete formattedAcitivity["startTimestamp"];    delete formattedAcitivity["endTimestamp"];    delete formattedAcitivity["largeImageKey"];    delete formattedAcitivity["smallImageKey"];    delete formattedAcitivity["largeImageText"];    delete formattedAcitivity["smallImageText"];    delete formattedAcitivity["partyId"];    delete formattedAcitivity["partyPrivacy"];    delete formattedAcitivity["partySize"];    delete formattedAcitivity["partyMax"];    delete formattedAcitivity["joinSecret"];    delete formattedAcitivity["spectateSecret"];    delete formattedAcitivity["matchSecret"];    delete formattedAcitivity["supportedPlatforms"];
    return (      await this.client.request("SET_ACTIVITY", {        pid: pid ?? process ? process.pid ?? 0 : 0,        activity: formattedAcitivity,      })    ).data;  }
  /**   * Used to clear a user's Rich Presence.   *   * @param pid - the application's process id   */  async clearActivity(pid?: number): Promise<void> {    await this.client.request("SET_ACTIVITY", {      pid: pid ?? Deno.pid,    });  }
  // #region Undocumented  // This region holds method that are not documented by Discord BUT does exist
  /**   * Create a new lobby   * @param type - lobby type   * @param capacity - lobby size   * @param locked - is lobby locked   * @param metadata - additional data?   * @returns lobby that user created   */  async createLobby(    type: LobbyType,    capacity?: number,    locked?: boolean,    metadata?: any,  ): Promise<Lobby> {    return new Lobby(      this.client,      (        await this.client.request("CREATE_LOBBY", {          type,          capacity,          locked,          metadata,        })      ).data,    );  }
  /**   * Used to join a new lobby.   * @param lobbyId - the id of the lobby to join   * @param secret - the secret of the lobby to join   * @returns the lobby that the user joined   */  async connectToLobby(lobbyId: string, secret: string): Promise<Lobby> {    return new Lobby(      this.client,      (        await this.client.request("CONNECT_TO_LOBBY", {          id: lobbyId,          secret,        })      ).data,    );  }
  /**   * Used to join a new lobby.   * @param lobbyId - the id of the lobby to join   * @param data - additional data to send to lobby   * @returns the lobby that the user joined   */  async sendToLobby(lobbyId: string, data: string): Promise<Lobby> {    return new Lobby(      this.client,      (        await this.client.request("SEND_TO_LOBBY", {          lobby_id: lobbyId,          data,        })      ).data,    );  }
  /**   * Used to get a user's avatar   * @param userId - id of the user to get the avatar of   * @param format - image format   * @param size - image size   * @return base64 encoded image data   */  async getImage(    userId: string,    format: "png" | "webp" | "jpg" = "png",    size: 16 | 32 | 64 | 128 | 256 | 512 | 1024 = 1024,  ): Promise<string> {    return (      await this.client.request("GET_IMAGE", {        type: "user",        id: userId,        format,        size,      })    ).data.data_url;  }
  // #endregion
  // #endregion}