@discordeno/bot 19.0.0-next.e2d86ea → 19.0.0-next.e30e5a2

package/dist/esm/transformers/integration.js

@@ -0,0 +1,34 @@
+import { iconHashToBigInt } from '../index.js';
+export function transformIntegration(bot, payload) {
+    const integration = {
+        guildId: bot.transformers.snowflake(payload.guild_id),
+        id: bot.transformers.snowflake(payload.id),
+        name: payload.name,
+        type: payload.type,
+        enabled: payload.enabled,
+        syncing: payload.syncing,
+        roleId: payload.role_id ? bot.transformers.snowflake(payload.role_id) : undefined,
+        enableEmoticons: payload.enable_emoticons,
+        expireBehavior: payload.expire_behavior,
+        expireGracePeriod: payload.expire_grace_period,
+        user: payload.user ? bot.transformers.user(bot, payload.user) : undefined,
+        account: {
+            id: bot.transformers.snowflake(payload.account.id),
+            name: payload.account.name
+        },
+        syncedAt: payload.synced_at ? Date.parse(payload.synced_at) : undefined,
+        subscriberCount: payload.subscriber_count,
+        revoked: payload.revoked,
+        application: payload.application ? {
+            id: bot.transformers.snowflake(payload.application.id),
+            name: payload.application.name,
+            icon: payload.application.icon ? iconHashToBigInt(payload.application.icon) : undefined,
+            description: payload.application.description,
+            bot: payload.application.bot ? bot.transformers.user(bot, payload.application.bot) : undefined
+        } : undefined,
+        scopes: payload.scopes
+    };
+    return bot.transformers.customizers.integration(bot, payload, integration);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transformers/interaction.js

@@ -0,0 +1,198 @@
+import { InteractionResponseTypes, InteractionTypes, MessageFlags } from '@discordeno/types';
+import { Collection } from '@discordeno/utils';
+import { DiscordApplicationIntegrationType } from '../index.js';
+const baseInteraction = {
+    async respond (response, options) {
+        let type = InteractionResponseTypes.ChannelMessageWithSource;
+        // If user provides a string, change it to a response object
+        if (typeof response === 'string') response = {
+            content: response
+        };
+        // If user provides an object, determine if it should be an autocomplete or a modal response
+        if (response.title) type = InteractionResponseTypes.Modal;
+        if (this.type === InteractionTypes.ApplicationCommandAutocomplete) type = InteractionResponseTypes.ApplicationCommandAutocompleteResult;
+        if (type === InteractionResponseTypes.ChannelMessageWithSource && options?.isPrivate) response.flags = MessageFlags.Ephemeral;
+        // Since this has already been given a response, any further responses must be followups.
+        if (this.acknowledged) return await this.bot.helpers.sendFollowupMessage(this.token, response);
+        // Modals cannot be chained
+        if (this.type === InteractionTypes.ModalSubmit && type === InteractionResponseTypes.Modal) throw new Error('Cannot respond to a modal interaction with another modal.');
+        this.acknowledged = true;
+        return await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type,
+            data: response
+        });
+    },
+    async edit (response, messageId) {
+        if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot edit an autocomplete interaction.');
+        // If user provides a string, change it to a response object
+        if (typeof response === 'string') response = {
+            content: response
+        };
+        if (messageId) {
+            return await this.bot?.helpers.editFollowupMessage(this.token, messageId, response);
+        }
+        if (!this.acknowledged) {
+            if (this.type !== InteractionTypes.MessageComponent) throw new Error("This interaction has not been responded to yet and this isn't a MessageComponent interaction.");
+            this.acknowledged = true;
+            return await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+                type: InteractionResponseTypes.UpdateMessage,
+                data: response
+            });
+        }
+        return await this.bot.helpers.editOriginalInteractionResponse(this.token, response);
+    },
+    async deferEdit () {
+        if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot edit an autocomplete interaction.');
+        if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.');
+        if (this.type !== InteractionTypes.MessageComponent) throw new Error("Cannot defer to then edit an interaction that isn't a MessageComponent interaction.");
+        this.acknowledged = true;
+        return await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type: InteractionResponseTypes.DeferredUpdateMessage
+        });
+    },
+    async defer (isPrivate) {
+        if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.');
+        this.acknowledged = true;
+        return await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type: InteractionResponseTypes.DeferredChannelMessageWithSource,
+            data: {
+                flags: isPrivate ? MessageFlags.Ephemeral : undefined
+            }
+        });
+    },
+    async delete (messageId) {
+        if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot delete an autocomplete interaction');
+        if (messageId) return await this.bot?.helpers.deleteFollowupMessage(this.token, messageId);
+        else return await this.bot?.helpers.deleteOriginalInteractionResponse(this.token);
+    }
+};
+export function transformInteraction(bot, payload) {
+    const guildId = payload.interaction.guild_id ? bot.transformers.snowflake(payload.interaction.guild_id) : undefined;
+    const user = bot.transformers.user(bot, payload.interaction.member?.user ?? payload.interaction.user);
+    const interaction = Object.create(baseInteraction);
+    const props = bot.transformers.desiredProperties.interaction;
+    interaction.bot = bot;
+    interaction.acknowledged = false;
+    if (props.id && payload.interaction.id) interaction.id = bot.transformers.snowflake(payload.interaction.id);
+    if (props.applicationId && payload.interaction.application_id) interaction.applicationId = bot.transformers.snowflake(payload.interaction.application_id);
+    if (props.type && payload.interaction.type) interaction.type = payload.interaction.type;
+    if (props.token && payload.interaction.token) interaction.token = payload.interaction.token;
+    if (props.version && payload.interaction.version) interaction.version = payload.interaction.version;
+    if (props.locale && payload.interaction.locale) interaction.locale = payload.interaction.locale;
+    if (props.guildLocale && payload.interaction.guild_locale) interaction.guildLocale = payload.interaction.guild_locale;
+    if (props.guild && payload.interaction.guild) // @ts-expect-error payload.interaction.guild is a Partial<DiscordGuild>
+    interaction.guild = bot.transformers.guild(bot, {
+        guild: payload.interaction.guild,
+        shardId: payload.shardId
+    });
+    if (props.guildId && guildId) interaction.guildId = guildId;
+    if (props.user && user) interaction.user = user;
+    if (props.appPermissions && payload.interaction.app_permissions) interaction.appPermissions = bot.transformers.snowflake(payload.interaction.app_permissions);
+    if (props.message && payload.interaction.message) interaction.message = bot.transformers.message(bot, payload.interaction.message);
+    if (props.channel && payload.interaction.channel) interaction.channel = bot.transformers.channel(bot, {
+        channel: payload.interaction.channel,
+        guildId
+    });
+    if (props.channelId && payload.interaction.channel_id) interaction.channelId = bot.transformers.snowflake(payload.interaction.channel_id);
+    if (props.member && guildId && payload.interaction.member) interaction.member = bot.transformers.member(bot, payload.interaction.member, guildId, user.id);
+    if (props.authorizingIntegrationOwners && payload.interaction.authorizing_integration_owners) {
+        interaction.authorizingIntegrationOwners = {};
+        if (payload.interaction.authorizing_integration_owners['0']) interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.GuildInstall] = bot.transformers.snowflake(payload.interaction.authorizing_integration_owners['0']);
+        if (payload.interaction.authorizing_integration_owners['1']) interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.UserInstall] = bot.transformers.snowflake(payload.interaction.authorizing_integration_owners['1']);
+    }
+    if (props.context && payload.interaction.context) interaction.context = payload.interaction.context;
+    if (props.data && payload.interaction.data) {
+        interaction.data = {
+            type: payload.interaction.data.type,
+            componentType: payload.interaction.data.component_type,
+            customId: payload.interaction.data.custom_id,
+            components: payload.interaction.data.components?.map((component)=>bot.transformers.component(bot, component)),
+            values: payload.interaction.data.values,
+            id: payload.interaction.data.id ? bot.transformers.snowflake(payload.interaction.data.id) : undefined,
+            name: payload.interaction.data.name,
+            resolved: payload.interaction.data.resolved ? transformInteractionDataResolved(bot, payload.interaction.data.resolved, guildId) : undefined,
+            options: payload.interaction.data.options?.map((opt)=>bot.transformers.interactionDataOptions(bot, opt)),
+            targetId: payload.interaction.data.target_id ? bot.transformers.snowflake(payload.interaction.data.target_id) : undefined
+        };
+    }
+    return bot.transformers.customizers.interaction(bot, payload, interaction);
+}
+export function transformInteractionDataOption(bot, option) {
+    const opt = {
+        name: option.name,
+        type: option.type,
+        value: option.value,
+        options: option.options,
+        focused: option.focused
+    };
+    return bot.transformers.customizers.interactionDataOptions(bot, option, opt);
+}
+export function transformInteractionDataResolved(bot, resolved, guildId) {
+    const transformed = {};
+    if (resolved.messages) {
+        transformed.messages = new Collection(Object.entries(resolved.messages).map(([id, value])=>{
+            const message = bot.transformers.message(bot, value);
+            return [
+                message.id,
+                message
+            ];
+        }));
+    }
+    if (resolved.users) {
+        transformed.users = new Collection(Object.entries(resolved.users).map(([id, value])=>{
+            const user = bot.transformers.user(bot, value);
+            return [
+                user.id,
+                user
+            ];
+        }));
+    }
+    if (guildId && resolved.members) {
+        transformed.members = new Collection(Object.entries(resolved.members).map(([id, value])=>{
+            const member = bot.transformers.member(bot, value, guildId, bot.transformers.snowflake(id));
+            return [
+                member.id,
+                member
+            ];
+        }));
+    }
+    if (guildId && resolved.roles) {
+        transformed.roles = new Collection(Object.entries(resolved.roles).map(([id, value])=>{
+            const role = bot.transformers.role(bot, {
+                role: value,
+                guildId
+            });
+            return [
+                role.id,
+                role
+            ];
+        }));
+    }
+    if (resolved.channels) {
+        transformed.channels = new Collection(Object.entries(resolved.channels).map(([key, value])=>{
+            const id = bot.transformers.snowflake(key);
+            const channel = value;
+            return [
+                id,
+                {
+                    id,
+                    name: channel.name,
+                    type: channel.type,
+                    permissions: bot.transformers.snowflake(channel.permissions)
+                }
+            ];
+        }));
+    }
+    if (resolved.attachments) {
+        transformed.attachments = new Collection(Object.entries(resolved.attachments).map(([key, value])=>{
+            const id = bot.transformers.snowflake(key);
+            return [
+                id,
+                bot.transformers.attachment(bot, value)
+            ];
+        }));
+    }
+    return transformed;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/transformers/interaction.ts"],"sourcesContent":["import {\n  InteractionResponseTypes,\n  InteractionTypes,\n  MessageFlags,\n  type ApplicationCommandOptionTypes,\n  type ApplicationCommandTypes,\n  type BigString,\n  type ChannelTypes,\n  type DiscordInteraction,\n  type DiscordInteractionDataOption,\n  type InteractionCallbackData,\n  type MessageComponentTypes,\n} from '@discordeno/types'\nimport { Collection } from '@discordeno/utils'\nimport {\n  DiscordApplicationIntegrationType,\n  type Bot,\n  type Channel,\n  type Component,\n  type DiscordChannel,\n  type DiscordInteractionContextType,\n  type Guild,\n} from '../index.js'\nimport type { DiscordInteractionDataResolved } from '../typings.js'\nimport type { Attachment } from './attachment.js'\nimport type { Member } from './member.js'\nimport type { Message } from './message.js'\nimport type { Role } from './role.js'\nimport type { User } from './user.js'\n\nexport interface Interaction extends BaseInteraction {\n  /** The bot object */\n  bot: Bot\n  /** Whether or not this interaction has been responded to. */\n  acknowledged: boolean\n  /** Id of the interaction */\n  id: bigint\n  /** Id of the application this interaction is for */\n  applicationId: bigint\n  /** The type of interaction */\n  type: InteractionTypes\n  /** Guild that the interaction was sent from */\n  guild: Guild\n  /** The guild it was sent from */\n  guildId?: bigint\n  /** The channel it was sent from */\n  channel: Partial<Channel>\n  /**\n   * The ID of channel it was sent from\n   *\n   * @remarks\n   * It is recommended that you begin using this channel field to identify the source channel of the interaction as they may deprecate the existing channel_id field in the future.\n   */\n  channelId?: bigint\n  /** Guild member data for the invoking user, including permissions */\n  member?: Member\n  /** User object for the invoking user, if invoked in a DM */\n  user: User\n  /** A continuation token for responding to the interaction */\n  token: string\n  /** Read-only property, always `1` */\n  version: 1\n  /** For the message the button was attached to */\n  message?: Message\n  /** the command data payload */\n  data?: {\n    type?: ApplicationCommandTypes\n    componentType?: MessageComponentTypes\n    customId?: string\n    components?: Component[]\n    values?: string[]\n    name: string\n    resolved?: InteractionDataResolved\n    options?: InteractionDataOption[]\n    id?: bigint\n    targetId?: bigint\n    // guildId?: bigint\n  }\n  /** The selected language of the invoking user */\n  locale?: string\n  /** The guild's preferred locale, if invoked in a guild */\n  guildLocale?: string\n  /** The computed permissions for a bot or app in the context of a specific interaction (including channel overwrites) */\n  appPermissions: bigint\n  /** Mapping of installation contexts that the interaction was authorized for to related user or guild IDs. */\n  authorizingIntegrationOwners: Partial<Record<DiscordApplicationIntegrationType, bigint>>\n  /** Context where the interaction was triggered from */\n  context?: DiscordInteractionContextType\n}\n\nexport interface BaseInteraction {\n  /**\n   * Sends a response to an interaction.\n   *\n   * @remarks\n   * This will send a {@link InteractionResponseTypes.ChannelMessageWithSource}, {@link InteractionResponseTypes.ApplicationCommandAutocompleteResult} or {@link InteractionResponseTypes.Modal} response based on the type of the interaction you are responding to.\n   *\n   * If the interaction has been already acknowledged, indicated by {@link Interaction.acknowledged}, it will send a followup message instead.\n   *\n   * Uses `interaction.type`, `interaction.token` and `interaction.id`, missing one of these in the desired proprieties may cause unexpected behavior.\n   */\n  respond: (response: string | InteractionCallbackData, options?: { isPrivate?: boolean }) => Promise<Message | void>\n  /**\n   * Edit the original response of an interaction or a followup if the message id is provided.\n   *\n   * @remarks\n   * This will edit the original interaction response or, if the interaction has not yet been acknowledged and the type of the interaction is {@link InteractionTypes.MessageComponent} it will instead send a {@link InteractionResponseTypes.UpdateMessage} response instead.\n   *\n   * Uses `interaction.type`, `interaction.token` and `interaction.id`, missing one of these in the desired proprieties may cause unexpected behavior.\n   */\n  edit: (response: string | InteractionCallbackData, messageId?: BigString) => Promise<Message | void>\n  /**\n   * Defer the interaction for updating the referenced message at a later time with {@link edit}.\n   *\n   * @remarks\n   * This will send a {@link InteractionResponseTypes.DeferredUpdateMessage} response.\n   *\n   * Uses `interaction.type`, `interaction.token` and `interaction.id`, missing one of these in the desired proprieties may cause unexpected behavior.\n   */\n  deferEdit: () => Promise<void>\n  /**\n   * Defer the interaction for updating the response at a later time with {@link edit}.\n   *\n   * @remarks\n   * This will send a {@link InteractionResponseTypes.DeferredChannelMessageWithSource} response.\n   *\n   * Uses `interaction.type`, `interaction.token` and `interaction.id`, missing one of these in the desired proprieties may cause unexpected behavior.\n   */\n  defer: (isPrivate?: boolean) => Promise<void>\n  /**\n   * Delete the original interaction response or a followup if the message id is provided.\n   *\n   * @remarks\n   * Uses `interaction.type` and `interaction.token`, missing one of these in the desired proprieties may cause unexpected behavior.\n   */\n  delete: (messageId?: BigString) => Promise<void>\n}\n\nconst baseInteraction: Partial<Interaction> & BaseInteraction = {\n  async respond(response, options) {\n    let type = InteractionResponseTypes.ChannelMessageWithSource\n\n    // If user provides a string, change it to a response object\n    if (typeof response === 'string') response = { content: response }\n\n    // If user provides an object, determine if it should be an autocomplete or a modal response\n    if (response.title) type = InteractionResponseTypes.Modal\n    if (this.type === InteractionTypes.ApplicationCommandAutocomplete) type = InteractionResponseTypes.ApplicationCommandAutocompleteResult\n    if (type === InteractionResponseTypes.ChannelMessageWithSource && options?.isPrivate) response.flags = MessageFlags.Ephemeral\n\n    // Since this has already been given a response, any further responses must be followups.\n    if (this.acknowledged) return await this.bot!.helpers.sendFollowupMessage(this.token!, response)\n\n    // Modals cannot be chained\n    if (this.type === InteractionTypes.ModalSubmit && type === InteractionResponseTypes.Modal)\n      throw new Error('Cannot respond to a modal interaction with another modal.')\n\n    this.acknowledged = true\n    return await this.bot!.helpers.sendInteractionResponse(this.id!, this.token!, { type, data: response })\n  },\n  async edit(response, messageId) {\n    if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot edit an autocomplete interaction.')\n\n    // If user provides a string, change it to a response object\n    if (typeof response === 'string') response = { content: response }\n\n    if (messageId) {\n      return await this.bot?.helpers.editFollowupMessage(this.token!, messageId, response)\n    }\n\n    if (!this.acknowledged) {\n      if (this.type !== InteractionTypes.MessageComponent)\n        throw new Error(\"This interaction has not been responded to yet and this isn't a MessageComponent interaction.\")\n\n      this.acknowledged = true\n      return await this.bot!.helpers.sendInteractionResponse(this.id!, this.token!, { type: InteractionResponseTypes.UpdateMessage, data: response })\n    }\n\n    return await this.bot!.helpers.editOriginalInteractionResponse(this.token!, response)\n  },\n  async deferEdit() {\n    if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot edit an autocomplete interaction.')\n    if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.')\n\n    if (this.type !== InteractionTypes.MessageComponent)\n      throw new Error(\"Cannot defer to then edit an interaction that isn't a MessageComponent interaction.\")\n\n    this.acknowledged = true\n    return await this.bot!.helpers.sendInteractionResponse(this.id!, this.token!, { type: InteractionResponseTypes.DeferredUpdateMessage })\n  },\n  async defer(isPrivate) {\n    if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.')\n\n    this.acknowledged = true\n    return await this.bot!.helpers.sendInteractionResponse(this.id!, this.token!, {\n      type: InteractionResponseTypes.DeferredChannelMessageWithSource,\n      data: {\n        flags: isPrivate ? MessageFlags.Ephemeral : undefined,\n      },\n    })\n  },\n  async delete(messageId) {\n    if (this.type === InteractionTypes.ApplicationCommandAutocomplete) throw new Error('Cannot delete an autocomplete interaction')\n\n    if (messageId) return await this.bot?.helpers.deleteFollowupMessage(this.token!, messageId)\n    else return await this.bot?.helpers.deleteOriginalInteractionResponse(this.token!)\n  },\n}\n\nexport function transformInteraction(bot: Bot, payload: { interaction: DiscordInteraction; shardId: number }): Interaction {\n  const guildId = payload.interaction.guild_id ? bot.transformers.snowflake(payload.interaction.guild_id) : undefined\n  const user = bot.transformers.user(bot, payload.interaction.member?.user ?? payload.interaction.user!)\n\n  const interaction: Interaction = Object.create(baseInteraction)\n  const props = bot.transformers.desiredProperties.interaction\n  interaction.bot = bot\n  interaction.acknowledged = false\n\n  if (props.id && payload.interaction.id) interaction.id = bot.transformers.snowflake(payload.interaction.id)\n  if (props.applicationId && payload.interaction.application_id)\n    interaction.applicationId = bot.transformers.snowflake(payload.interaction.application_id)\n  if (props.type && payload.interaction.type) interaction.type = payload.interaction.type\n  if (props.token && payload.interaction.token) interaction.token = payload.interaction.token\n  if (props.version && payload.interaction.version) interaction.version = payload.interaction.version\n  if (props.locale && payload.interaction.locale) interaction.locale = payload.interaction.locale\n  if (props.guildLocale && payload.interaction.guild_locale) interaction.guildLocale = payload.interaction.guild_locale\n  if (props.guild && payload.interaction.guild)\n    // @ts-expect-error payload.interaction.guild is a Partial<DiscordGuild>\n    interaction.guild = bot.transformers.guild(bot, { guild: payload.interaction.guild, shardId: payload.shardId })\n  if (props.guildId && guildId) interaction.guildId = guildId\n  if (props.user && user) interaction.user = user\n  if (props.appPermissions && payload.interaction.app_permissions)\n    interaction.appPermissions = bot.transformers.snowflake(payload.interaction.app_permissions)\n  if (props.message && payload.interaction.message) interaction.message = bot.transformers.message(bot, payload.interaction.message)\n  if (props.channel && payload.interaction.channel)\n    interaction.channel = bot.transformers.channel(bot, { channel: payload.interaction.channel as DiscordChannel, guildId })\n  if (props.channelId && payload.interaction.channel_id) interaction.channelId = bot.transformers.snowflake(payload.interaction.channel_id)\n  if (props.member && guildId && payload.interaction.member)\n    interaction.member = bot.transformers.member(bot, payload.interaction.member, guildId, user.id)\n  if (props.authorizingIntegrationOwners && payload.interaction.authorizing_integration_owners) {\n    interaction.authorizingIntegrationOwners = {}\n\n    if (payload.interaction.authorizing_integration_owners['0'])\n      interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.GuildInstall] = bot.transformers.snowflake(\n        payload.interaction.authorizing_integration_owners['0'],\n      )\n    if (payload.interaction.authorizing_integration_owners['1'])\n      interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.UserInstall] = bot.transformers.snowflake(\n        payload.interaction.authorizing_integration_owners['1'],\n      )\n  }\n  if (props.context && payload.interaction.context) interaction.context = payload.interaction.context\n  if (props.data && payload.interaction.data) {\n    interaction.data = {\n      type: payload.interaction.data.type,\n      componentType: payload.interaction.data.component_type,\n      customId: payload.interaction.data.custom_id,\n      components: payload.interaction.data.components?.map((component) => bot.transformers.component(bot, component)),\n      values: payload.interaction.data.values,\n      id: payload.interaction.data.id ? bot.transformers.snowflake(payload.interaction.data.id) : undefined,\n      name: payload.interaction.data.name,\n      resolved: payload.interaction.data.resolved ? transformInteractionDataResolved(bot, payload.interaction.data.resolved, guildId) : undefined,\n      options: payload.interaction.data.options?.map((opt) => bot.transformers.interactionDataOptions(bot, opt)),\n      targetId: payload.interaction.data.target_id ? bot.transformers.snowflake(payload.interaction.data.target_id) : undefined,\n      // guildId: payload.interaction.data.guild_id ? bot.transformers.snowflake(payload.interaction.data.guild_id) : undefined,\n    }\n  }\n\n  return bot.transformers.customizers.interaction(bot, payload, interaction)\n}\n\nexport function transformInteractionDataOption(bot: Bot, option: DiscordInteractionDataOption): InteractionDataOption {\n  const opt = {\n    name: option.name,\n    type: option.type,\n    value: option.value,\n    options: option.options,\n    focused: option.focused,\n  } as InteractionDataOption\n\n  return bot.transformers.customizers.interactionDataOptions(bot, option, opt)\n}\n\nexport function transformInteractionDataResolved(bot: Bot, resolved: DiscordInteractionDataResolved, guildId?: bigint): InteractionDataResolved {\n  const transformed: InteractionDataResolved = {}\n\n  if (resolved.messages) {\n    transformed.messages = new Collection(\n      Object.entries(resolved.messages).map(([id, value]) => {\n        const message: Message = bot.transformers.message(bot, value)\n        return [message.id, message]\n      }),\n    )\n  }\n\n  if (resolved.users) {\n    transformed.users = new Collection(\n      Object.entries(resolved.users).map(([id, value]) => {\n        const user = bot.transformers.user(bot, value)\n        return [user.id, user]\n      }),\n    )\n  }\n\n  if (guildId && resolved.members) {\n    transformed.members = new Collection(\n      Object.entries(resolved.members).map(([id, value]) => {\n        const member: Member = bot.transformers.member(bot, value, guildId, bot.transformers.snowflake(id))\n        return [member.id, member]\n      }),\n    )\n  }\n\n  if (guildId && resolved.roles) {\n    transformed.roles = new Collection(\n      Object.entries(resolved.roles).map(([id, value]) => {\n        const role = bot.transformers.role(bot, { role: value, guildId })\n        return [role.id, role]\n      }),\n    )\n  }\n\n  if (resolved.channels) {\n    transformed.channels = new Collection(\n      Object.entries(resolved.channels).map(([key, value]) => {\n        const id = bot.transformers.snowflake(key)\n        const channel = value as {\n          id: string\n          name: string\n          type: ChannelTypes\n          permissions: string\n        }\n        return [\n          id,\n          {\n            id,\n            name: channel.name,\n            type: channel.type,\n            permissions: bot.transformers.snowflake(channel.permissions),\n          },\n        ]\n      }),\n    )\n  }\n\n  if (resolved.attachments) {\n    transformed.attachments = new Collection(\n      Object.entries(resolved.attachments).map(([key, value]) => {\n        const id = bot.transformers.snowflake(key)\n        return [id, bot.transformers.attachment(bot, value)]\n      }),\n    )\n  }\n\n  return transformed\n}\n\nexport interface InteractionDataResolved {\n  messages?: Collection<bigint, Message>\n  users?: Collection<bigint, User>\n  members?: Collection<bigint, Member>\n  roles?: Collection<bigint, Role>\n  channels?: Collection<bigint, { id: bigint; name: string; type: ChannelTypes; permissions: bigint }>\n  attachments?: Collection<bigint, Attachment>\n}\n\nexport interface InteractionDataOption {\n  name: string\n  type: ApplicationCommandOptionTypes\n  value?: string | number | boolean\n  options?: InteractionDataOption[]\n  focused?: boolean\n}\n"],"names":["InteractionResponseTypes","InteractionTypes","MessageFlags","Collection","DiscordApplicationIntegrationType","baseInteraction","respond","response","options","type","ChannelMessageWithSource","content","title","Modal","ApplicationCommandAutocomplete","ApplicationCommandAutocompleteResult","isPrivate","flags","Ephemeral","acknowledged","bot","helpers","sendFollowupMessage","token","ModalSubmit","Error","sendInteractionResponse","id","data","edit","messageId","editFollowupMessage","MessageComponent","UpdateMessage","editOriginalInteractionResponse","deferEdit","DeferredUpdateMessage","defer","DeferredChannelMessageWithSource","undefined","delete","deleteFollowupMessage","deleteOriginalInteractionResponse","transformInteraction","payload","guildId","interaction","guild_id","transformers","snowflake","user","member","Object","create","props","desiredProperties","applicationId","application_id","version","locale","guildLocale","guild_locale","guild","shardId","appPermissions","app_permissions","message","channel","channelId","channel_id","authorizingIntegrationOwners","authorizing_integration_owners","GuildInstall","UserInstall","context","componentType","component_type","customId","custom_id","components","map","component","values","name","resolved","transformInteractionDataResolved","opt","interactionDataOptions","targetId","target_id","customizers","transformInteractionDataOption","option","value","focused","transformed","messages","entries","users","members","roles","role","channels","key","permissions","attachments","attachment"],"mappings":"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"}

package/dist/esm/transformers/invite.js

@@ -0,0 +1,41 @@
+import { isInviteWithMetadata } from '../index.js';
+export function transformInvite(bot, payload) {
+    const props = bot.transformers.desiredProperties.invite;
+    const invite = {};
+    if (props.type && 'type' in payload.invite) invite.type = payload.invite.type;
+    if (props.code && payload.invite.code) invite.code = payload.invite.code;
+    if (props.createdAt && payload.invite.created_at) invite.createdAt = Date.parse(payload.invite.created_at);
+    if (props.inviter && payload.invite.inviter) invite.inviter = bot.transformers.user(bot, payload.invite.inviter);
+    if (props.maxAge) invite.maxAge = payload.invite.max_age;
+    if (props.maxUses) invite.maxUses = payload.invite.max_uses;
+    if (props.targetType && payload.invite.target_type) invite.targetType = payload.invite.target_type;
+    if (props.targetUser && payload.invite.target_user) invite.targetUser = bot.transformers.user(bot, payload.invite.target_user);
+    if (props.targetApplication && payload.invite.target_application) invite.targetApplication = bot.transformers.application(bot, {
+        application: payload.invite.target_application,
+        shardId: payload.shardId
+    });
+    if (props.temporary && payload.invite.temporary) invite.temporary = payload.invite.temporary;
+    if (props.uses && payload.invite.uses) invite.uses = payload.invite.uses;
+    if (isInviteWithMetadata(payload.invite)) {
+        if (props.channelId && payload.invite.channel?.id) invite.channelId = bot.transformers.snowflake(payload.invite.channel.id);
+        if (props.guildId && payload.invite.guild?.id) invite.guildId = bot.transformers.snowflake(payload.invite.guild.id);
+        if (props.approximateMemberCount && payload.invite.approximate_member_count) invite.approximateMemberCount = payload.invite.approximate_member_count;
+        if (props.approximatePresenceCount && payload.invite.approximate_presence_count !== undefined) invite.approximatePresenceCount = payload.invite.approximate_presence_count;
+        if (props.guildScheduledEvent && payload.invite.guild_scheduled_event) invite.guildScheduledEvent = bot.transformers.scheduledEvent(bot, payload.invite.guild_scheduled_event);
+        if (props.stageInstance && invite.guildId && payload.invite.stage_instance) {
+            invite.stageInstance = bot.transformers.inviteStageInstance(bot, {
+                ...payload.invite.stage_instance,
+                guildId: invite.guildId
+            });
+        }
+        if (props.expiresAt && payload.invite.expires_at) {
+            invite.expiresAt = Date.parse(payload.invite.expires_at);
+        }
+    } else {
+        if (props.channelId && payload.invite.channel_id) invite.channelId = bot.transformers.snowflake(payload.invite.channel_id);
+        if (props.guildId && payload.invite.guild_id) invite.guildId = bot.transformers.snowflake(payload.invite.guild_id);
+    }
+    return bot.transformers.customizers.invite(bot, payload.invite, invite);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/transformers/invite.ts"],"sourcesContent":["import type { DiscordApplication, DiscordInviteCreate, DiscordInviteMetadata, DiscordInviteType } from '@discordeno/types'\nimport { isInviteWithMetadata, type Application, type Bot, type ScheduledEvent, type User } from '../index.js'\nimport type { InviteStageInstance } from './stageInviteInstance.js'\n\nexport function transformInvite(bot: Bot, payload: { invite: DiscordInviteCreate | DiscordInviteMetadata; shardId: number }): Invite {\n  const props = bot.transformers.desiredProperties.invite\n  const invite = {} as Invite\n\n  if (props.type && 'type' in payload.invite) invite.type = payload.invite.type\n  if (props.code && payload.invite.code) invite.code = payload.invite.code\n  if (props.createdAt && payload.invite.created_at) invite.createdAt = Date.parse(payload.invite.created_at)\n  if (props.inviter && payload.invite.inviter) invite.inviter = bot.transformers.user(bot, payload.invite.inviter)\n  if (props.maxAge) invite.maxAge = payload.invite.max_age\n  if (props.maxUses) invite.maxUses = payload.invite.max_uses\n  if (props.targetType && payload.invite.target_type) invite.targetType = payload.invite.target_type\n  if (props.targetUser && payload.invite.target_user) invite.targetUser = bot.transformers.user(bot, payload.invite.target_user)\n  if (props.targetApplication && payload.invite.target_application)\n    invite.targetApplication = bot.transformers.application(bot, {\n      application: payload.invite.target_application as DiscordApplication,\n      shardId: payload.shardId,\n    })\n  if (props.temporary && payload.invite.temporary) invite.temporary = payload.invite.temporary\n  if (props.uses && payload.invite.uses) invite.uses = payload.invite.uses\n\n  if (isInviteWithMetadata(payload.invite)) {\n    if (props.channelId && payload.invite.channel?.id) invite.channelId = bot.transformers.snowflake(payload.invite.channel.id)\n    if (props.guildId && payload.invite.guild?.id) invite.guildId = bot.transformers.snowflake(payload.invite.guild.id)\n    if (props.approximateMemberCount && payload.invite.approximate_member_count)\n      invite.approximateMemberCount = payload.invite.approximate_member_count\n    if (props.approximatePresenceCount && payload.invite.approximate_presence_count !== undefined)\n      invite.approximatePresenceCount = payload.invite.approximate_presence_count\n    if (props.guildScheduledEvent && payload.invite.guild_scheduled_event)\n      invite.guildScheduledEvent = bot.transformers.scheduledEvent(bot, payload.invite.guild_scheduled_event)\n    if (props.stageInstance && invite.guildId && payload.invite.stage_instance) {\n      invite.stageInstance = bot.transformers.inviteStageInstance(bot, {\n        ...payload.invite.stage_instance,\n        guildId: invite.guildId,\n      })\n    }\n    if (props.expiresAt && payload.invite.expires_at) {\n      invite.expiresAt = Date.parse(payload.invite.expires_at)\n    }\n  } else {\n    if (props.channelId && payload.invite.channel_id) invite.channelId = bot.transformers.snowflake(payload.invite.channel_id)\n    if (props.guildId && payload.invite.guild_id) invite.guildId = bot.transformers.snowflake(payload.invite.guild_id)\n  }\n\n  return bot.transformers.customizers.invite(bot, payload.invite, invite)\n}\n\nexport interface Invite {\n  /** The type of invite */\n  type: DiscordInviteType\n  /** The channel the invite is for */\n  channelId: bigint\n  /** The unique invite code */\n  code: string\n  /** The time at which the invite was created */\n  createdAt: number\n  /** The guild of the invite */\n  guildId?: bigint\n  /** The user that created the invite */\n  inviter?: User\n  /** How long the invite is valid for (in seconds) */\n  maxAge: number\n  /** The maximum number of times the invite can be used */\n  maxUses: number\n  /** The type of target for this voice channel invite */\n  targetType: number\n  /** The target user for this invite */\n  targetUser: User\n  /** The embedded application to open for this voice channel embedded application invite */\n  targetApplication?: Application\n  /** Whether or not the invite is temporary (invited users will be kicked on disconnect unless they're assigned a role) */\n  temporary: boolean\n  /** How many times the invite has been used (always will be 0) */\n  uses: number\n  /** Approximate count of online members (only present when target_user is set) */\n  approximateMemberCount: number\n  /** Stage instance data if there is a public Stage instance in the Stage channel this invite is for */\n  stageInstance?: InviteStageInstance\n  /** The expiration date of this invite, returned from the GET /invites/code endpoint when with_expiration is true */\n  expiresAt?: number\n  /** guild scheduled event data */\n  guildScheduledEvent?: ScheduledEvent\n  /** Approximate count of online members (only present when target_user is set) */\n  approximatePresenceCount?: number\n}\n"],"names":["isInviteWithMetadata","transformInvite","bot","payload","props","transformers","desiredProperties","invite","type","code","createdAt","created_at","Date","parse","inviter","user","maxAge","max_age","maxUses","max_uses","targetType","target_type","targetUser","target_user","targetApplication","target_application","application","shardId","temporary","uses","channelId","channel","id","snowflake","guildId","guild","approximateMemberCount","approximate_member_count","approximatePresenceCount","approximate_presence_count","undefined","guildScheduledEvent","guild_scheduled_event","scheduledEvent","stageInstance","stage_instance","inviteStageInstance","expiresAt","expires_at","channel_id","guild_id","customizers"],"mappings":"AACA,SAASA,oBAAoB,QAAoE,cAAa;AAG9G,OAAO,SAASC,gBAAgBC,GAAQ,EAAEC,OAAiF;IACzH,MAAMC,QAAQF,IAAIG,YAAY,CAACC,iBAAiB,CAACC,MAAM;IACvD,MAAMA,SAAS,CAAC;IAEhB,IAAIH,MAAMI,IAAI,IAAI,UAAUL,QAAQI,MAAM,EAAEA,OAAOC,IAAI,GAAGL,QAAQI,MAAM,CAACC,IAAI;IAC7E,IAAIJ,MAAMK,IAAI,IAAIN,QAAQI,MAAM,CAACE,IAAI,EAAEF,OAAOE,IAAI,GAAGN,QAAQI,MAAM,CAACE,IAAI;IACxE,IAAIL,MAAMM,SAAS,IAAIP,QAAQI,MAAM,CAACI,UAAU,EAAEJ,OAAOG,SAAS,GAAGE,KAAKC,KAAK,CAACV,QAAQI,MAAM,CAACI,UAAU;IACzG,IAAIP,MAAMU,OAAO,IAAIX,QAAQI,MAAM,CAACO,OAAO,EAAEP,OAAOO,OAAO,GAAGZ,IAAIG,YAAY,CAACU,IAAI,CAACb,KAAKC,QAAQI,MAAM,CAACO,OAAO;IAC/G,IAAIV,MAAMY,MAAM,EAAET,OAAOS,MAAM,GAAGb,QAAQI,MAAM,CAACU,OAAO;IACxD,IAAIb,MAAMc,OAAO,EAAEX,OAAOW,OAAO,GAAGf,QAAQI,MAAM,CAACY,QAAQ;IAC3D,IAAIf,MAAMgB,UAAU,IAAIjB,QAAQI,MAAM,CAACc,WAAW,EAAEd,OAAOa,UAAU,GAAGjB,QAAQI,MAAM,CAACc,WAAW;IAClG,IAAIjB,MAAMkB,UAAU,IAAInB,QAAQI,MAAM,CAACgB,WAAW,EAAEhB,OAAOe,UAAU,GAAGpB,IAAIG,YAAY,CAACU,IAAI,CAACb,KAAKC,QAAQI,MAAM,CAACgB,WAAW;IAC7H,IAAInB,MAAMoB,iBAAiB,IAAIrB,QAAQI,MAAM,CAACkB,kBAAkB,EAC9DlB,OAAOiB,iBAAiB,GAAGtB,IAAIG,YAAY,CAACqB,WAAW,CAACxB,KAAK;QAC3DwB,aAAavB,QAAQI,MAAM,CAACkB,kBAAkB;QAC9CE,SAASxB,QAAQwB,OAAO;IAC1B;IACF,IAAIvB,MAAMwB,SAAS,IAAIzB,QAAQI,MAAM,CAACqB,SAAS,EAAErB,OAAOqB,SAAS,GAAGzB,QAAQI,MAAM,CAACqB,SAAS;IAC5F,IAAIxB,MAAMyB,IAAI,IAAI1B,QAAQI,MAAM,CAACsB,IAAI,EAAEtB,OAAOsB,IAAI,GAAG1B,QAAQI,MAAM,CAACsB,IAAI;IAExE,IAAI7B,qBAAqBG,QAAQI,MAAM,GAAG;QACxC,IAAIH,MAAM0B,SAAS,IAAI3B,QAAQI,MAAM,CAACwB,OAAO,EAAEC,IAAIzB,OAAOuB,SAAS,GAAG5B,IAAIG,YAAY,CAAC4B,SAAS,CAAC9B,QAAQI,MAAM,CAACwB,OAAO,CAACC,EAAE;QAC1H,IAAI5B,MAAM8B,OAAO,IAAI/B,QAAQI,MAAM,CAAC4B,KAAK,EAAEH,IAAIzB,OAAO2B,OAAO,GAAGhC,IAAIG,YAAY,CAAC4B,SAAS,CAAC9B,QAAQI,MAAM,CAAC4B,KAAK,CAACH,EAAE;QAClH,IAAI5B,MAAMgC,sBAAsB,IAAIjC,QAAQI,MAAM,CAAC8B,wBAAwB,EACzE9B,OAAO6B,sBAAsB,GAAGjC,QAAQI,MAAM,CAAC8B,wBAAwB;QACzE,IAAIjC,MAAMkC,wBAAwB,IAAInC,QAAQI,MAAM,CAACgC,0BAA0B,KAAKC,WAClFjC,OAAO+B,wBAAwB,GAAGnC,QAAQI,MAAM,CAACgC,0BAA0B;QAC7E,IAAInC,MAAMqC,mBAAmB,IAAItC,QAAQI,MAAM,CAACmC,qBAAqB,EACnEnC,OAAOkC,mBAAmB,GAAGvC,IAAIG,YAAY,CAACsC,cAAc,CAACzC,KAAKC,QAAQI,MAAM,CAACmC,qBAAqB;QACxG,IAAItC,MAAMwC,aAAa,IAAIrC,OAAO2B,OAAO,IAAI/B,QAAQI,MAAM,CAACsC,cAAc,EAAE;YAC1EtC,OAAOqC,aAAa,GAAG1C,IAAIG,YAAY,CAACyC,mBAAmB,CAAC5C,KAAK;gBAC/D,GAAGC,QAAQI,MAAM,CAACsC,cAAc;gBAChCX,SAAS3B,OAAO2B,OAAO;YACzB;QACF;QACA,IAAI9B,MAAM2C,SAAS,IAAI5C,QAAQI,MAAM,CAACyC,UAAU,EAAE;YAChDzC,OAAOwC,SAAS,GAAGnC,KAAKC,KAAK,CAACV,QAAQI,MAAM,CAACyC,UAAU;QACzD;IACF,OAAO;QACL,IAAI5C,MAAM0B,SAAS,IAAI3B,QAAQI,MAAM,CAAC0C,UAAU,EAAE1C,OAAOuB,SAAS,GAAG5B,IAAIG,YAAY,CAAC4B,SAAS,CAAC9B,QAAQI,MAAM,CAAC0C,UAAU;QACzH,IAAI7C,MAAM8B,OAAO,IAAI/B,QAAQI,MAAM,CAAC2C,QAAQ,EAAE3C,OAAO2B,OAAO,GAAGhC,IAAIG,YAAY,CAAC4B,SAAS,CAAC9B,QAAQI,MAAM,CAAC2C,QAAQ;IACnH;IAEA,OAAOhD,IAAIG,YAAY,CAAC8C,WAAW,CAAC5C,MAAM,CAACL,KAAKC,QAAQI,MAAM,EAAEA;AAClE"}

package/dist/esm/transformers/member.js

@@ -0,0 +1,35 @@
+import { iconHashToBigInt } from '@discordeno/utils';
+import { Permissions } from './toggles/Permissions.js';
+import { MemberToggles } from './toggles/member.js';
+const baseMember = {
+    get deaf () {
+        return !!this.toggles?.has('deaf');
+    },
+    get mute () {
+        return !!this.toggles?.has('mute');
+    },
+    get pending () {
+        return !!this.toggles?.has('pending');
+    }
+};
+export function transformMember(bot, payload, guildId, userId) {
+    const member = Object.create(baseMember);
+    const props = bot.transformers.desiredProperties.member;
+    if (props.id && userId) member.id = typeof userId === 'string' ? bot.transformers.snowflake(userId) : userId;
+    if (props.guildId && guildId) member.guildId = typeof guildId === 'string' ? bot.transformers.snowflake(guildId) : guildId;
+    if (props.user && payload.user) member.user = bot.transformers.user(bot, payload.user);
+    if (props.nick && payload.nick) member.nick = payload.nick;
+    if (props.roles && payload.roles) member.roles = payload.roles.map((id)=>bot.transformers.snowflake(id));
+    if (props.joinedAt && payload.joined_at) member.joinedAt = Date.parse(payload.joined_at);
+    if (props.premiumSince && payload.premium_since) member.premiumSince = Date.parse(payload.premium_since);
+    if (props.communicationDisabledUntil && payload.communication_disabled_until) member.communicationDisabledUntil = Date.parse(payload.communication_disabled_until);
+    if (props.avatar && payload.avatar) member.avatar = iconHashToBigInt(payload.avatar);
+    if (props.permissions && payload.permissions) member.permissions = new Permissions(payload.permissions);
+    if (props.deaf || props.mute || props.pending) {
+        member.toggles = new MemberToggles(payload);
+    }
+    if (props.avatarDecorationData && payload.avatar_decoration_data) member.avatarDecorationData = bot.transformers.avatarDecorationData(bot, payload.avatar_decoration_data);
+    return bot.transformers.customizers.member(bot, payload, member);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/transformers/member.ts"],"sourcesContent":["import type { BigString, DiscordMember } from '@discordeno/types'\nimport { iconHashToBigInt } from '@discordeno/utils'\nimport type { Bot } from '../bot.js'\nimport type { AvatarDecorationData } from './avatarDecorationData.js'\nimport { Permissions } from './toggles/Permissions.js'\nimport { MemberToggles } from './toggles/member.js'\nimport type { User } from './user.js'\n\nconst baseMember: Partial<Member> & BaseMember = {\n  get deaf() {\n    return !!this.toggles?.has('deaf')\n  },\n  get mute() {\n    return !!this.toggles?.has('mute')\n  },\n  get pending() {\n    return !!this.toggles?.has('pending')\n  },\n}\n\nexport function transformMember(bot: Bot, payload: DiscordMember, guildId: BigString, userId: BigString): Member {\n  const member: Member = Object.create(baseMember)\n  const props = bot.transformers.desiredProperties.member\n\n  if (props.id && userId) member.id = typeof userId === 'string' ? bot.transformers.snowflake(userId) : userId\n  if (props.guildId && guildId) member.guildId = typeof guildId === 'string' ? bot.transformers.snowflake(guildId) : guildId\n  if (props.user && payload.user) member.user = bot.transformers.user(bot, payload.user)\n  if (props.nick && payload.nick) member.nick = payload.nick\n  if (props.roles && payload.roles) member.roles = payload.roles.map((id) => bot.transformers.snowflake(id))\n  if (props.joinedAt && payload.joined_at) member.joinedAt = Date.parse(payload.joined_at)\n  if (props.premiumSince && payload.premium_since) member.premiumSince = Date.parse(payload.premium_since)\n  if (props.communicationDisabledUntil && payload.communication_disabled_until)\n    member.communicationDisabledUntil = Date.parse(payload.communication_disabled_until)\n  if (props.avatar && payload.avatar) member.avatar = iconHashToBigInt(payload.avatar)\n  if (props.permissions && payload.permissions) member.permissions = new Permissions(payload.permissions)\n  if (props.deaf || props.mute || props.pending) {\n    member.toggles = new MemberToggles(payload)\n  }\n  if (props.avatarDecorationData && payload.avatar_decoration_data)\n    member.avatarDecorationData = bot.transformers.avatarDecorationData(bot, payload.avatar_decoration_data)\n\n  return bot.transformers.customizers.member(bot, payload, member)\n}\n\nexport interface BaseMember {\n  /** Whether the user is deafened in voice channels */\n  deaf?: boolean\n  /** Whether the user is muted in voice channels */\n  mute?: boolean\n  /** Whether the user has not yet passed the guild's Membership Screening requirements */\n  pending?: boolean\n}\n\nexport interface Member extends BaseMember {\n  /** The user id of the member. */\n  id: bigint\n  /** The compressed form of all the boolean values on this user. */\n  toggles?: MemberToggles\n  /** The guild id where this member is. */\n  guildId: bigint\n  /** The user this guild member represents */\n  user?: User\n  /** This users guild nickname */\n  nick?: string\n  /** The members custom avatar for this server. */\n  avatar?: bigint\n  /** Array of role object ids */\n  roles: bigint[]\n  /** When the user joined the guild */\n  joinedAt: number\n  /** When the user started boosting the guild */\n  premiumSince?: number\n  /** The permissions this member has in the guild. Only present on interaction events. */\n  permissions?: Permissions\n  /** when the user's timeout will expire and the user will be able to communicate in the guild again (set null to remove timeout), null or a time in the past if the user is not timed out */\n  communicationDisabledUntil?: number\n  /** data for the member's guild avatar decoration */\n  avatarDecorationData: AvatarDecorationData\n}\n"],"names":["iconHashToBigInt","Permissions","MemberToggles","baseMember","deaf","toggles","has","mute","pending","transformMember","bot","payload","guildId","userId","member","Object","create","props","transformers","desiredProperties","id","snowflake","user","nick","roles","map","joinedAt","joined_at","Date","parse","premiumSince","premium_since","communicationDisabledUntil","communication_disabled_until","avatar","permissions","avatarDecorationData","avatar_decoration_data","customizers"],"mappings":"AACA,SAASA,gBAAgB,QAAQ,oBAAmB;AAGpD,SAASC,WAAW,QAAQ,2BAA0B;AACtD,SAASC,aAAa,QAAQ,sBAAqB;AAGnD,MAAMC,aAA2C;IAC/C,IAAIC,QAAO;QACT,OAAO,CAAC,CAAC,IAAI,CAACC,OAAO,EAAEC,IAAI;IAC7B;IACA,IAAIC,QAAO;QACT,OAAO,CAAC,CAAC,IAAI,CAACF,OAAO,EAAEC,IAAI;IAC7B;IACA,IAAIE,WAAU;QACZ,OAAO,CAAC,CAAC,IAAI,CAACH,OAAO,EAAEC,IAAI;IAC7B;AACF;AAEA,OAAO,SAASG,gBAAgBC,GAAQ,EAAEC,OAAsB,EAAEC,OAAkB,EAAEC,MAAiB;IACrG,MAAMC,SAAiBC,OAAOC,MAAM,CAACb;IACrC,MAAMc,QAAQP,IAAIQ,YAAY,CAACC,iBAAiB,CAACL,MAAM;IAEvD,IAAIG,MAAMG,EAAE,IAAIP,QAAQC,OAAOM,EAAE,GAAG,OAAOP,WAAW,WAAWH,IAAIQ,YAAY,CAACG,SAAS,CAACR,UAAUA;IACtG,IAAII,MAAML,OAAO,IAAIA,SAASE,OAAOF,OAAO,GAAG,OAAOA,YAAY,WAAWF,IAAIQ,YAAY,CAACG,SAAS,CAACT,WAAWA;IACnH,IAAIK,MAAMK,IAAI,IAAIX,QAAQW,IAAI,EAAER,OAAOQ,IAAI,GAAGZ,IAAIQ,YAAY,CAACI,IAAI,CAACZ,KAAKC,QAAQW,IAAI;IACrF,IAAIL,MAAMM,IAAI,IAAIZ,QAAQY,IAAI,EAAET,OAAOS,IAAI,GAAGZ,QAAQY,IAAI;IAC1D,IAAIN,MAAMO,KAAK,IAAIb,QAAQa,KAAK,EAAEV,OAAOU,KAAK,GAAGb,QAAQa,KAAK,CAACC,GAAG,CAAC,CAACL,KAAOV,IAAIQ,YAAY,CAACG,SAAS,CAACD;IACtG,IAAIH,MAAMS,QAAQ,IAAIf,QAAQgB,SAAS,EAAEb,OAAOY,QAAQ,GAAGE,KAAKC,KAAK,CAAClB,QAAQgB,SAAS;IACvF,IAAIV,MAAMa,YAAY,IAAInB,QAAQoB,aAAa,EAAEjB,OAAOgB,YAAY,GAAGF,KAAKC,KAAK,CAAClB,QAAQoB,aAAa;IACvG,IAAId,MAAMe,0BAA0B,IAAIrB,QAAQsB,4BAA4B,EAC1EnB,OAAOkB,0BAA0B,GAAGJ,KAAKC,KAAK,CAAClB,QAAQsB,4BAA4B;IACrF,IAAIhB,MAAMiB,MAAM,IAAIvB,QAAQuB,MAAM,EAAEpB,OAAOoB,MAAM,GAAGlC,iBAAiBW,QAAQuB,MAAM;IACnF,IAAIjB,MAAMkB,WAAW,IAAIxB,QAAQwB,WAAW,EAAErB,OAAOqB,WAAW,GAAG,IAAIlC,YAAYU,QAAQwB,WAAW;IACtG,IAAIlB,MAAMb,IAAI,IAAIa,MAAMV,IAAI,IAAIU,MAAMT,OAAO,EAAE;QAC7CM,OAAOT,OAAO,GAAG,IAAIH,cAAcS;IACrC;IACA,IAAIM,MAAMmB,oBAAoB,IAAIzB,QAAQ0B,sBAAsB,EAC9DvB,OAAOsB,oBAAoB,GAAG1B,IAAIQ,YAAY,CAACkB,oBAAoB,CAAC1B,KAAKC,QAAQ0B,sBAAsB;IAEzG,OAAO3B,IAAIQ,YAAY,CAACoB,WAAW,CAACxB,MAAM,CAACJ,KAAKC,SAASG;AAC3D"}