@discordeno/bot 21.0.1-next.fca0b40 → 22.0.1-next.f274ec6

package/dist/transformers/interaction.js

@@ -0,0 +1,258 @@
+import { DiscordApplicationIntegrationType, InteractionResponseTypes, InteractionTypes, MessageFlags } from '@discordeno/types';
+import { Collection } from '@discordeno/utils';
+// Assume we have all desired properties for this or else typescript will get very confused for the return types of these functions.
+// This is used as a prototype, so the actual type with the user desired properties will be set later.
+export const baseInteraction = {
+    // This allows typescript to still check for type errors on functions below
+    ...undefined,
+    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 ??= 0;
+            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.');
+        const result = await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type,
+            data: response
+        }, {
+            withResponse: options?.withResponse
+        });
+        this.acknowledged = true;
+        return result;
+    },
+    async edit (response, messageId, options) {
+        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 && this.type !== InteractionTypes.ModalSubmit) throw new Error("This interaction has not been responded to yet and this isn't a MessageComponent or ModalSubmit interaction.");
+            const result = await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+                type: InteractionResponseTypes.UpdateMessage,
+                data: response
+            }, options);
+            this.acknowledged = true;
+            return result;
+        }
+        return await this.bot.helpers.editOriginalInteractionResponse(this.token, response);
+    },
+    async deferEdit (options) {
+        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 && this.type !== InteractionTypes.ModalSubmit) throw new Error("Cannot defer to then edit an interaction that isn't a MessageComponent or ModalSubmit interaction.");
+        const result = await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type: InteractionResponseTypes.DeferredUpdateMessage
+        }, options);
+        this.acknowledged = true;
+        return result;
+    },
+    async defer (isPrivate, options) {
+        if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.');
+        const result = await this.bot.helpers.sendInteractionResponse(this.id, this.token, {
+            type: InteractionResponseTypes.DeferredChannelMessageWithSource,
+            data: {
+                flags: isPrivate ? MessageFlags.Ephemeral : undefined
+            }
+        }, options);
+        this.acknowledged = true;
+        return result;
+    },
+    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, extra) {
+    const guildId = payload.guild_id ? bot.transformers.snowflake(payload.guild_id) : undefined;
+    const interaction = Object.create(baseInteraction);
+    const props = bot.transformers.desiredProperties.interaction;
+    interaction.bot = bot;
+    interaction.acknowledged = false;
+    if (props.id && payload.id) interaction.id = bot.transformers.snowflake(payload.id);
+    if (props.applicationId && payload.application_id) interaction.applicationId = bot.transformers.snowflake(payload.application_id);
+    if (props.type && payload.type) interaction.type = payload.type;
+    if (props.token && payload.token) interaction.token = payload.token;
+    if (props.version && payload.version) interaction.version = payload.version;
+    if (props.locale && payload.locale) interaction.locale = payload.locale;
+    if (props.guildLocale && payload.guild_locale) interaction.guildLocale = payload.guild_locale;
+    if (props.guild && payload.guild) // @ts-expect-error payload.guild is a Partial<DiscordGuild>
+    interaction.guild = bot.transformers.guild(bot, payload.guild, {
+        shardId: extra?.shardId
+    });
+    if (props.guildId && guildId) interaction.guildId = guildId;
+    if (props.user) {
+        if (payload.member?.user) interaction.user = bot.transformers.user(bot, payload.member?.user);
+        else if (payload.user) interaction.user = bot.transformers.user(bot, payload.user);
+    }
+    if (props.appPermissions && payload.app_permissions) interaction.appPermissions = bot.transformers.snowflake(payload.app_permissions);
+    if (props.message && payload.message) interaction.message = bot.transformers.message(bot, payload.message, {
+        shardId: extra?.shardId
+    });
+    if (props.channel && payload.channel) // @ts-expect-error payload.channel is a Partial<>
+    interaction.channel = bot.transformers.channel(bot, payload.channel, {
+        guildId
+    });
+    if (props.channelId && payload.channel_id) interaction.channelId = bot.transformers.snowflake(payload.channel_id);
+    if (props.member && guildId && payload.member) interaction.member = bot.transformers.member(bot, payload.member, {
+        guildId,
+        userId: payload.member?.user.id ?? payload.user?.id
+    });
+    if (props.entitlements && payload.entitlements) interaction.entitlements = payload.entitlements.map((e)=>bot.transformers.entitlement(bot, e));
+    if (props.authorizingIntegrationOwners && payload.authorizing_integration_owners) {
+        interaction.authorizingIntegrationOwners = {};
+        if (payload.authorizing_integration_owners['0']) interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.GuildInstall] = bot.transformers.snowflake(payload.authorizing_integration_owners['0']);
+        if (payload.authorizing_integration_owners['1']) interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.UserInstall] = bot.transformers.snowflake(payload.authorizing_integration_owners['1']);
+    }
+    if (props.context && payload.context) interaction.context = payload.context;
+    if (props.attachmentSizeLimit && payload.attachment_size_limit) interaction.attachmentSizeLimit = payload.attachment_size_limit;
+    if (props.data && payload.data) {
+        interaction.data = {
+            type: payload.data.type,
+            componentType: payload.data.component_type,
+            customId: payload.data.custom_id,
+            components: payload.data.components?.map((component)=>bot.transformers.component(bot, component)),
+            values: payload.data.values,
+            id: payload.data.id ? bot.transformers.snowflake(payload.data.id) : undefined,
+            name: payload.data.name,
+            resolved: payload.data.resolved ? bot.transformers.interactionDataResolved(bot, payload.data.resolved, {
+                shardId: extra?.shardId,
+                guildId
+            }) : undefined,
+            options: payload.data.options?.map((opt)=>bot.transformers.interactionDataOptions(bot, opt)),
+            targetId: payload.data.target_id ? bot.transformers.snowflake(payload.data.target_id) : undefined
+        };
+    }
+    // Typescript has an hard time with interaction.bot, so we need to tell him for sure this interaction is the of the correct type
+    return bot.transformers.customizers.interaction(bot, payload, interaction, extra);
+}
+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, payload, extra) {
+    const transformed = {};
+    if (payload.messages) {
+        transformed.messages = new Collection(Object.entries(payload.messages).map(([_id, value])=>{
+            // @ts-expect-error TODO: Deal with partials
+            const message = bot.transformers.message(bot, value, {
+                shardId: extra?.shardId
+            });
+            return [
+                message.id,
+                message
+            ];
+        }));
+    }
+    if (payload.users) {
+        transformed.users = new Collection(Object.entries(payload.users).map(([_id, value])=>{
+            const user = bot.transformers.user(bot, value);
+            return [
+                user.id,
+                user
+            ];
+        }));
+    }
+    if (extra?.guildId && payload.members) {
+        transformed.members = new Collection(Object.entries(payload.members).map(([id, value])=>{
+            // @ts-expect-error TODO: Deal with partials, value is missing 2 values but the transformer can handle it, despite what the types says
+            const member = bot.transformers.member(bot, value, {
+                guildId: extra.guildId,
+                userId: bot.transformers.snowflake(id)
+            });
+            // We need to tell TS that we are sure the id is a bigint
+            return [
+                member.id,
+                member
+            ];
+        }));
+    }
+    if (extra?.guildId && payload.roles) {
+        transformed.roles = new Collection(Object.entries(payload.roles).map(([_id, value])=>{
+            const role = bot.transformers.role(bot, value, {
+                guildId: extra.guildId
+            });
+            return [
+                role.id,
+                role
+            ];
+        }));
+    }
+    if (payload.channels) {
+        transformed.channels = new Collection(Object.entries(payload.channels).map(([_id, value])=>{
+            const channel = bot.transformers.channel(bot, value);
+            // We need to tell TS that we are sure the id is a bigint
+            return [
+                channel.id,
+                channel
+            ];
+        }));
+    }
+    if (payload.attachments) {
+        transformed.attachments = new Collection(Object.entries(payload.attachments).map(([key, value])=>{
+            const id = bot.transformers.snowflake(key);
+            const attachment = bot.transformers.attachment(bot, value);
+            return [
+                id,
+                attachment
+            ];
+        }));
+    }
+    return bot.transformers.customizers.interactionDataResolved(bot, payload, transformed, {
+        shardId: extra?.shardId,
+        guildId: extra?.guildId ? bot.transformers.snowflake(extra.guildId) : undefined
+    });
+}
+export function transformInteractionCallbackResponse(bot, payload, extra) {
+    const props = bot.transformers.desiredProperties.interactionCallbackResponse;
+    const response = {};
+    if (props.interaction && payload.interaction) response.interaction = bot.transformers.interactionCallback(bot, payload.interaction);
+    if (props.resource && payload.resource) response.resource = bot.transformers.interactionResource(bot, payload.resource, {
+        shardId: extra?.shardId
+    });
+    return bot.transformers.customizers.interactionCallbackResponse(bot, payload, response, extra);
+}
+export function transformInteractionCallback(bot, payload) {
+    const props = bot.transformers.desiredProperties.interactionCallback;
+    const callback = {};
+    if (props.id && payload.id) callback.id = bot.transformers.snowflake(payload.id);
+    if (props.type && payload.type) callback.type = payload.type;
+    if (props.activityInstanceId && payload.activity_instance_id) callback.activityInstanceId = payload.activity_instance_id;
+    if (props.responseMessageId && payload.response_message_id) callback.responseMessageId = bot.transformers.snowflake(payload.response_message_id);
+    if (props.responseMessageEphemeral && payload.response_message_ephemeral) callback.responseMessageEphemeral = payload.response_message_ephemeral;
+    if (props.responseMessageLoading && payload.response_message_loading) callback.responseMessageLoading = payload.response_message_loading;
+    return bot.transformers.customizers.interactionCallback(bot, payload, callback);
+}
+export function transformInteractionResource(bot, payload, extra) {
+    const props = bot.transformers.desiredProperties.interactionResource;
+    const resource = {};
+    if (props.type && payload.type) resource.type = payload.type;
+    if (props.activityInstance && payload.activity_instance) resource.activityInstance = payload.activity_instance;
+    if (props.message && payload.message) resource.message = bot.transformers.message(bot, payload.message, {
+        shardId: extra?.shardId
+    });
+    return bot.transformers.customizers.interactionResource(bot, payload, resource, extra);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/transformers/interaction.ts"],"sourcesContent":["import {\n  DiscordApplicationIntegrationType,\n  type DiscordInteraction,\n  type DiscordInteractionCallback,\n  type DiscordInteractionCallbackResponse,\n  type DiscordInteractionDataOption,\n  type DiscordInteractionDataResolved,\n  type DiscordInteractionResource,\n  InteractionResponseTypes,\n  InteractionTypes,\n  MessageFlags,\n} from '@discordeno/types'\nimport { Collection } from '@discordeno/utils'\nimport type {\n  Attachment,\n  BigString,\n  Bot,\n  CompleteDesiredProperties,\n  DesiredPropertiesBehavior,\n  Interaction,\n  InteractionCallback,\n  InteractionCallbackResponse,\n  InteractionDataOption,\n  InteractionDataResolved,\n  InteractionResolvedDataChannel,\n  InteractionResolvedDataMember,\n  InteractionResource,\n  Message,\n  Role,\n  SetupDesiredProps,\n  TransformersDesiredProperties,\n  TransformProperty,\n  User,\n} from '../index.js'\n\n// Assume we have all desired properties for this or else typescript will get very confused for the return types of these functions.\n// This is used as a prototype, so the actual type with the user desired properties will be set later.\nexport const baseInteraction: SetupDesiredProps<Interaction, CompleteDesiredProperties<{}, true>, DesiredPropertiesBehavior.RemoveKey> = {\n  // This allows typescript to still check for type errors on functions below\n  ...(undefined as unknown as SetupDesiredProps<Interaction, CompleteDesiredProperties<{}, true>, DesiredPropertiesBehavior.RemoveKey>),\n\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) {\n      response.flags ??= 0\n      response.flags |= MessageFlags.Ephemeral\n    }\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    const result = await this.bot.helpers.sendInteractionResponse(\n      this.id,\n      this.token,\n      { type, data: response },\n      { withResponse: options?.withResponse },\n    )\n    this.acknowledged = true\n    return result\n  },\n  async edit(response, messageId, options) {\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 && this.type !== InteractionTypes.ModalSubmit)\n        throw new Error(\"This interaction has not been responded to yet and this isn't a MessageComponent or ModalSubmit interaction.\")\n\n      const result = await this.bot.helpers.sendInteractionResponse(\n        this.id,\n        this.token,\n        { type: InteractionResponseTypes.UpdateMessage, data: response },\n        options,\n      )\n      this.acknowledged = true\n      return result\n    }\n\n    return await this.bot.helpers.editOriginalInteractionResponse(this.token, response)\n  },\n  async deferEdit(options) {\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 && this.type !== InteractionTypes.ModalSubmit)\n      throw new Error(\"Cannot defer to then edit an interaction that isn't a MessageComponent or ModalSubmit interaction.\")\n\n    const result = await this.bot.helpers.sendInteractionResponse(\n      this.id,\n      this.token,\n      { type: InteractionResponseTypes.DeferredUpdateMessage },\n      options,\n    )\n    this.acknowledged = true\n    return result\n  },\n  async defer(isPrivate, options) {\n    if (this.acknowledged) throw new Error('Cannot defer an already responded interaction.')\n\n    const result = await this.bot.helpers.sendInteractionResponse(\n      this.id,\n      this.token,\n      {\n        type: InteractionResponseTypes.DeferredChannelMessageWithSource,\n        data: {\n          flags: isPrivate ? MessageFlags.Ephemeral : undefined,\n        },\n      },\n      options,\n    )\n    this.acknowledged = true\n    return result\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: DiscordInteraction, extra?: { shardId?: number }): Interaction {\n  const guildId = payload.guild_id ? bot.transformers.snowflake(payload.guild_id) : undefined\n\n  const interaction: SetupDesiredProps<Interaction, TransformersDesiredProperties, DesiredPropertiesBehavior> = Object.create(baseInteraction)\n  const props = bot.transformers.desiredProperties.interaction\n\n  interaction.bot = bot\n  interaction.acknowledged = false\n\n  if (props.id && payload.id) interaction.id = bot.transformers.snowflake(payload.id)\n  if (props.applicationId && payload.application_id) interaction.applicationId = bot.transformers.snowflake(payload.application_id)\n  if (props.type && payload.type) interaction.type = payload.type\n  if (props.token && payload.token) interaction.token = payload.token\n  if (props.version && payload.version) interaction.version = payload.version\n  if (props.locale && payload.locale) interaction.locale = payload.locale\n  if (props.guildLocale && payload.guild_locale) interaction.guildLocale = payload.guild_locale\n  if (props.guild && payload.guild)\n    // @ts-expect-error payload.guild is a Partial<DiscordGuild>\n    interaction.guild = bot.transformers.guild(bot, payload.guild, { shardId: extra?.shardId })\n  if (props.guildId && guildId) interaction.guildId = guildId\n  if (props.user) {\n    if (payload.member?.user) interaction.user = bot.transformers.user(bot, payload.member?.user)\n    else if (payload.user) interaction.user = bot.transformers.user(bot, payload.user)\n  }\n  if (props.appPermissions && payload.app_permissions) interaction.appPermissions = bot.transformers.snowflake(payload.app_permissions)\n  if (props.message && payload.message) interaction.message = bot.transformers.message(bot, payload.message, { shardId: extra?.shardId })\n  if (props.channel && payload.channel)\n    // @ts-expect-error payload.channel is a Partial<>\n    interaction.channel = bot.transformers.channel(bot, payload.channel, { guildId })\n  if (props.channelId && payload.channel_id) interaction.channelId = bot.transformers.snowflake(payload.channel_id)\n  if (props.member && guildId && payload.member)\n    interaction.member = bot.transformers.member(bot, payload.member, {\n      guildId,\n      userId: payload.member?.user.id ?? payload.user?.id,\n    })\n  if (props.entitlements && payload.entitlements) interaction.entitlements = payload.entitlements.map((e) => bot.transformers.entitlement(bot, e))\n  if (props.authorizingIntegrationOwners && payload.authorizing_integration_owners) {\n    interaction.authorizingIntegrationOwners = {}\n\n    if (payload.authorizing_integration_owners['0'])\n      interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.GuildInstall] = bot.transformers.snowflake(\n        payload.authorizing_integration_owners['0'],\n      )\n    if (payload.authorizing_integration_owners['1'])\n      interaction.authorizingIntegrationOwners[DiscordApplicationIntegrationType.UserInstall] = bot.transformers.snowflake(\n        payload.authorizing_integration_owners['1'],\n      )\n  }\n  if (props.context && payload.context) interaction.context = payload.context\n  if (props.attachmentSizeLimit && payload.attachment_size_limit) interaction.attachmentSizeLimit = payload.attachment_size_limit\n  if (props.data && payload.data) {\n    interaction.data = {\n      type: payload.data.type,\n      componentType: payload.data.component_type,\n      customId: payload.data.custom_id,\n      components: payload.data.components?.map((component) => bot.transformers.component(bot, component)),\n      values: payload.data.values,\n      id: payload.data.id ? bot.transformers.snowflake(payload.data.id) : undefined,\n      name: payload.data.name,\n      resolved: payload.data.resolved\n        ? bot.transformers.interactionDataResolved(bot, payload.data.resolved, { shardId: extra?.shardId, guildId })\n        : undefined,\n      options: payload.data.options?.map((opt) => bot.transformers.interactionDataOptions(bot, opt)),\n      targetId: payload.data.target_id ? bot.transformers.snowflake(payload.data.target_id) : undefined,\n    }\n  }\n\n  // Typescript has an hard time with interaction.bot, so we need to tell him for sure this interaction is the of the correct type\n  return bot.transformers.customizers.interaction(bot, payload, interaction as unknown as typeof bot.transformers.$inferredTypes.interaction, extra)\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(\n  bot: Bot,\n  payload: DiscordInteractionDataResolved,\n  extra?: { shardId?: number; guildId?: BigString },\n): TransformProperty<InteractionDataResolved, TransformersDesiredProperties, DesiredPropertiesBehavior.RemoveKey> {\n  const transformed: InteractionDataResolved = {}\n\n  if (payload.messages) {\n    transformed.messages = new Collection(\n      Object.entries(payload.messages).map(([_id, value]) => {\n        // @ts-expect-error TODO: Deal with partials\n        const message = bot.transformers.message(bot, value, { shardId: extra?.shardId }) as Message\n        return [message.id, message]\n      }),\n    )\n  }\n\n  if (payload.users) {\n    transformed.users = new Collection(\n      Object.entries(payload.users).map(([_id, value]) => {\n        const user = bot.transformers.user(bot, value) as User\n        return [user.id, user]\n      }),\n    )\n  }\n\n  if (extra?.guildId && payload.members) {\n    transformed.members = new Collection(\n      Object.entries(payload.members).map(([id, value]) => {\n        // @ts-expect-error TODO: Deal with partials, value is missing 2 values but the transformer can handle it, despite what the types says\n        const member = bot.transformers.member(bot, value, {\n          guildId: extra.guildId,\n          userId: bot.transformers.snowflake(id),\n        }) as InteractionResolvedDataMember<TransformersDesiredProperties, DesiredPropertiesBehavior>\n\n        // We need to tell TS that we are sure the id is a bigint\n        return [member.id as bigint, member]\n      }),\n    )\n  }\n\n  if (extra?.guildId && payload.roles) {\n    transformed.roles = new Collection(\n      Object.entries(payload.roles).map(([_id, value]) => {\n        const role = bot.transformers.role(bot, value, { guildId: extra.guildId }) as Role\n        return [role.id, role]\n      }),\n    )\n  }\n\n  if (payload.channels) {\n    transformed.channels = new Collection(\n      Object.entries(payload.channels).map(([_id, value]) => {\n        const channel = bot.transformers.channel(bot, value) as unknown as InteractionResolvedDataChannel<\n          TransformersDesiredProperties,\n          DesiredPropertiesBehavior\n        >\n        // We need to tell TS that we are sure the id is a bigint\n        return [channel.id as bigint, channel]\n      }),\n    )\n  }\n\n  if (payload.attachments) {\n    transformed.attachments = new Collection(\n      Object.entries(payload.attachments).map(([key, value]) => {\n        const id = bot.transformers.snowflake(key)\n        const attachment = bot.transformers.attachment(bot, value) as Attachment\n        return [id, attachment]\n      }),\n    )\n  }\n\n  return bot.transformers.customizers.interactionDataResolved(bot, payload, transformed, {\n    shardId: extra?.shardId,\n    guildId: extra?.guildId ? bot.transformers.snowflake(extra.guildId) : undefined,\n  })\n}\n\nexport function transformInteractionCallbackResponse(\n  bot: Bot,\n  payload: DiscordInteractionCallbackResponse,\n  extra?: { shardId?: number },\n): InteractionCallbackResponse {\n  const props = bot.transformers.desiredProperties.interactionCallbackResponse\n  const response = {} as SetupDesiredProps<InteractionCallbackResponse, TransformersDesiredProperties, DesiredPropertiesBehavior>\n\n  if (props.interaction && payload.interaction) response.interaction = bot.transformers.interactionCallback(bot, payload.interaction)\n  if (props.resource && payload.resource) response.resource = bot.transformers.interactionResource(bot, payload.resource, { shardId: extra?.shardId })\n\n  return bot.transformers.customizers.interactionCallbackResponse(bot, payload, response, extra)\n}\n\nexport function transformInteractionCallback(bot: Bot, payload: DiscordInteractionCallback): InteractionCallback {\n  const props = bot.transformers.desiredProperties.interactionCallback\n  const callback = {} as SetupDesiredProps<InteractionCallback, TransformersDesiredProperties, DesiredPropertiesBehavior>\n\n  if (props.id && payload.id) callback.id = bot.transformers.snowflake(payload.id)\n  if (props.type && payload.type) callback.type = payload.type\n  if (props.activityInstanceId && payload.activity_instance_id) callback.activityInstanceId = payload.activity_instance_id\n  if (props.responseMessageId && payload.response_message_id) callback.responseMessageId = bot.transformers.snowflake(payload.response_message_id)\n  if (props.responseMessageEphemeral && payload.response_message_ephemeral) callback.responseMessageEphemeral = payload.response_message_ephemeral\n  if (props.responseMessageLoading && payload.response_message_loading) callback.responseMessageLoading = payload.response_message_loading\n\n  return bot.transformers.customizers.interactionCallback(bot, payload, callback)\n}\n\nexport function transformInteractionResource(bot: Bot, payload: DiscordInteractionResource, extra?: { shardId?: number }): InteractionResource {\n  const props = bot.transformers.desiredProperties.interactionResource\n  const resource = {} as SetupDesiredProps<InteractionResource, TransformersDesiredProperties, DesiredPropertiesBehavior>\n\n  if (props.type && payload.type) resource.type = payload.type\n  if (props.activityInstance && payload.activity_instance) resource.activityInstance = payload.activity_instance\n  if (props.message && payload.message) resource.message = bot.transformers.message(bot, payload.message, { shardId: extra?.shardId })\n\n  return bot.transformers.customizers.interactionResource(bot, payload, resource, extra)\n}\n"],"names":["DiscordApplicationIntegrationType","InteractionResponseTypes","InteractionTypes","MessageFlags","Collection","baseInteraction","undefined","respond","response","options","type","ChannelMessageWithSource","content","title","Modal","ApplicationCommandAutocomplete","ApplicationCommandAutocompleteResult","isPrivate","flags","Ephemeral","acknowledged","bot","helpers","sendFollowupMessage","token","ModalSubmit","Error","result","sendInteractionResponse","id","data","withResponse","edit","messageId","editFollowupMessage","MessageComponent","UpdateMessage","editOriginalInteractionResponse","deferEdit","DeferredUpdateMessage","defer","DeferredChannelMessageWithSource","delete","deleteFollowupMessage","deleteOriginalInteractionResponse","transformInteraction","payload","extra","guildId","guild_id","transformers","snowflake","interaction","Object","create","props","desiredProperties","applicationId","application_id","version","locale","guildLocale","guild_locale","guild","shardId","user","member","appPermissions","app_permissions","message","channel","channelId","channel_id","userId","entitlements","map","e","entitlement","authorizingIntegrationOwners","authorizing_integration_owners","GuildInstall","UserInstall","context","attachmentSizeLimit","attachment_size_limit","componentType","component_type","customId","custom_id","components","component","values","name","resolved","interactionDataResolved","opt","interactionDataOptions","targetId","target_id","customizers","transformInteractionDataOption","option","value","focused","transformInteractionDataResolved","transformed","messages","entries","_id","users","members","roles","role","channels","attachments","key","attachment","transformInteractionCallbackResponse","interactionCallbackResponse","interactionCallback","resource","interactionResource","transformInteractionCallback","callback","activityInstanceId","activity_instance_id","responseMessageId","response_message_id","responseMessageEphemeral","response_message_ephemeral","responseMessageLoading","response_message_loading","transformInteractionResource","activityInstance","activity_instance"],"mappings":"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"}

package/dist/transformers/invite.d.ts

@@ -0,0 +1,6 @@
+import type { DiscordInviteCreate, DiscordInviteMetadata } from '@discordeno/types';
+import { type Bot, type Invite } from '../index.js';
+export declare function transformInvite(bot: Bot, payload: DiscordInviteCreate | DiscordInviteMetadata, extra?: {
+    shardId?: number;
+}): Invite;
+//# sourceMappingURL=invite.d.ts.map

package/dist/transformers/invite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite.d.ts","sourceRoot":"","sources":["../../src/transformers/invite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AACnF,OAAO,EACL,KAAK,GAAG,EAER,KAAK,MAAM,EAKZ,MAAM,aAAa,CAAA;AAEpB,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,mBAAmB,GAAG,qBAAqB,EAAE,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAuCpI"}

package/dist/transformers/invite.js

@@ -0,0 +1,41 @@
+import { isInviteWithMetadata, ToggleBitfield } from '../index.js';
+export function transformInvite(bot, payload, extra) {
+    const props = bot.transformers.desiredProperties.invite;
+    const invite = {};
+    if (props.type && 'type' in payload) invite.type = payload.type;
+    if (props.code && payload.code) invite.code = payload.code;
+    if (props.createdAt && payload.created_at) invite.createdAt = Date.parse(payload.created_at);
+    if (props.inviter && payload.inviter) invite.inviter = bot.transformers.user(bot, payload.inviter);
+    if (props.maxAge) invite.maxAge = payload.max_age;
+    if (props.maxUses) invite.maxUses = payload.max_uses;
+    if (props.targetType && payload.target_type) invite.targetType = payload.target_type;
+    if (props.targetUser && payload.target_user) invite.targetUser = bot.transformers.user(bot, payload.target_user);
+    if (props.targetApplication && payload.target_application) // @ts-expect-error TODO: Partials
+    invite.targetApplication = bot.transformers.application(bot, payload.target_application, {
+        shardId: extra?.shardId
+    });
+    if (props.temporary && payload.temporary) invite.temporary = payload.temporary;
+    if (props.uses && payload.uses) invite.uses = payload.uses;
+    if (isInviteWithMetadata(payload)) {
+        if (props.channelId && payload.channel?.id) invite.channelId = bot.transformers.snowflake(payload.channel.id);
+        if (props.guildId && payload.guild?.id) invite.guildId = bot.transformers.snowflake(payload.guild.id);
+        if (props.approximateMemberCount && payload.approximate_member_count) invite.approximateMemberCount = payload.approximate_member_count;
+        if (props.approximatePresenceCount && payload.approximate_presence_count !== undefined) invite.approximatePresenceCount = payload.approximate_presence_count;
+        if (props.guildScheduledEvent && payload.guild_scheduled_event) invite.guildScheduledEvent = bot.transformers.scheduledEvent(bot, payload.guild_scheduled_event);
+        if (props.stageInstance && payload.guild?.id && payload.stage_instance) {
+            invite.stageInstance = bot.transformers.inviteStageInstance(bot, payload.stage_instance, {
+                guildId: payload.guild.id
+            });
+        }
+        if (props.expiresAt && payload.expires_at) {
+            invite.expiresAt = Date.parse(payload.expires_at);
+        }
+        if (props.flags && payload.flags) invite.flags = new ToggleBitfield(payload.flags);
+    } else {
+        if (props.channelId && payload.channel_id) invite.channelId = bot.transformers.snowflake(payload.channel_id);
+        if (props.guildId && payload.guild_id) invite.guildId = bot.transformers.snowflake(payload.guild_id);
+    }
+    return bot.transformers.customizers.invite(bot, payload, invite, extra);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/transformers/invite.ts"],"sourcesContent":["import type { DiscordInviteCreate, DiscordInviteMetadata } from '@discordeno/types'\nimport {\n  type Bot,\n  type DesiredPropertiesBehavior,\n  type Invite,\n  isInviteWithMetadata,\n  type SetupDesiredProps,\n  ToggleBitfield,\n  type TransformersDesiredProperties,\n} from '../index.js'\n\nexport function transformInvite(bot: Bot, payload: DiscordInviteCreate | DiscordInviteMetadata, extra?: { shardId?: number }): Invite {\n  const props = bot.transformers.desiredProperties.invite\n  const invite = {} as SetupDesiredProps<Invite, TransformersDesiredProperties, DesiredPropertiesBehavior>\n\n  if (props.type && 'type' in payload) invite.type = payload.type\n  if (props.code && payload.code) invite.code = payload.code\n  if (props.createdAt && payload.created_at) invite.createdAt = Date.parse(payload.created_at)\n  if (props.inviter && payload.inviter) invite.inviter = bot.transformers.user(bot, payload.inviter)\n  if (props.maxAge) invite.maxAge = payload.max_age\n  if (props.maxUses) invite.maxUses = payload.max_uses\n  if (props.targetType && payload.target_type) invite.targetType = payload.target_type\n  if (props.targetUser && payload.target_user) invite.targetUser = bot.transformers.user(bot, payload.target_user)\n  if (props.targetApplication && payload.target_application)\n    // @ts-expect-error TODO: Partials\n    invite.targetApplication = bot.transformers.application(bot, payload.target_application, { shardId: extra?.shardId })\n  if (props.temporary && payload.temporary) invite.temporary = payload.temporary\n  if (props.uses && payload.uses) invite.uses = payload.uses\n\n  if (isInviteWithMetadata(payload)) {\n    if (props.channelId && payload.channel?.id) invite.channelId = bot.transformers.snowflake(payload.channel.id)\n    if (props.guildId && payload.guild?.id) invite.guildId = bot.transformers.snowflake(payload.guild.id)\n    if (props.approximateMemberCount && payload.approximate_member_count) invite.approximateMemberCount = payload.approximate_member_count\n    if (props.approximatePresenceCount && payload.approximate_presence_count !== undefined)\n      invite.approximatePresenceCount = payload.approximate_presence_count\n    if (props.guildScheduledEvent && payload.guild_scheduled_event)\n      invite.guildScheduledEvent = bot.transformers.scheduledEvent(bot, payload.guild_scheduled_event)\n    if (props.stageInstance && payload.guild?.id && payload.stage_instance) {\n      invite.stageInstance = bot.transformers.inviteStageInstance(bot, payload.stage_instance, { guildId: payload.guild.id })\n    }\n    if (props.expiresAt && payload.expires_at) {\n      invite.expiresAt = Date.parse(payload.expires_at)\n    }\n    if (props.flags && payload.flags) invite.flags = new ToggleBitfield(payload.flags)\n  } else {\n    if (props.channelId && payload.channel_id) invite.channelId = bot.transformers.snowflake(payload.channel_id)\n    if (props.guildId && payload.guild_id) invite.guildId = bot.transformers.snowflake(payload.guild_id)\n  }\n\n  return bot.transformers.customizers.invite(bot, payload, invite, extra)\n}\n"],"names":["isInviteWithMetadata","ToggleBitfield","transformInvite","bot","payload","extra","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","flags","channel_id","guild_id","customizers"],"mappings":"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"}

package/dist/transformers/lobby.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lobby.d.ts","sourceRoot":"","sources":["../../src/transformers/lobby.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EACL,KAAK,GAAG,EAER,KAAK,KAAK,EACV,KAAK,WAAW,EAIjB,MAAM,aAAa,CAAA;AAEpB,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,GAAG,KAAK,CAWrE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,kBAAkB,GAAG,WAAW,CASvF"}

package/dist/transformers/lobby.js

@@ -0,0 +1,21 @@
+import { ToggleBitfield } from '../index.js';
+export function transformLobby(bot, payload) {
+    const props = bot.transformers.desiredProperties.lobby;
+    const lobby = {};
+    if (props.id && payload.id) lobby.id = bot.transformers.snowflake(payload.id);
+    if (props.applicationId && payload.application_id) lobby.applicationId = bot.transformers.snowflake(payload.application_id);
+    if (props.metadata && payload.metadata) lobby.metadata = payload.metadata;
+    if (props.members && payload.members) lobby.members = payload.members.map((member)=>bot.transformers.lobbyMember(bot, member));
+    if (props.linkedChannel && payload.linked_channel) lobby.linkedChannel = bot.transformers.channel(bot, payload.linked_channel);
+    return bot.transformers.customizers.lobby(bot, payload, lobby);
+}
+export function transformLobbyMember(bot, payload) {
+    const props = bot.transformers.desiredProperties.lobbyMember;
+    const lobbyMember = {};
+    if (props.id && payload.id) lobbyMember.id = bot.transformers.snowflake(payload.id);
+    if (props.metadata && payload.metadata) lobbyMember.metadata = payload.metadata;
+    if (props.flags && payload.flags) lobbyMember.flags = new ToggleBitfield(payload.flags);
+    return bot.transformers.customizers.lobbyMember(bot, payload, lobbyMember);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/transformers/member.d.ts

@@ -0,0 +1,9 @@
+import type { BigString, DiscordMember } from '@discordeno/types';
+import type { Bot } from '../bot.js';
+import type { Member } from './types.js';
+export declare const baseMember: Member;
+export declare function transformMember(bot: Bot, payload: DiscordMember, extra?: {
+    guildId?: BigString;
+    userId?: BigString;
+}): Member;
+//# sourceMappingURL=member.d.ts.map

package/dist/transformers/member.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member.d.ts","sourceRoot":"","sources":["../../src/transformers/member.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAIpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,eAAO,MAAM,UAAU,EAAE,MA4BxB,CAAA;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,CAwB7H"}

package/dist/transformers/member.js

@@ -0,0 +1,54 @@
+import { iconHashToBigInt } from '@discordeno/utils';
+import { MemberToggles } from './toggles/member.js';
+import { Permissions } from './toggles/Permissions.js';
+export const baseMember = {
+    // This allows typescript to still check for type errors on functions below
+    ...undefined,
+    get deaf () {
+        return !!this.toggles?.has('deaf');
+    },
+    get mute () {
+        return !!this.toggles?.has('mute');
+    },
+    get pending () {
+        return !!this.toggles?.has('pending');
+    },
+    get flags () {
+        return this.toggles?.flags ?? 0;
+    },
+    get didRejoin () {
+        return !!this.toggles?.didRejoin;
+    },
+    get startedOnboarding () {
+        return !!this.toggles?.startedOnboarding;
+    },
+    get bypassesVerification () {
+        return !!this.toggles?.bypassesVerification;
+    },
+    get completedOnboarding () {
+        return !!this.toggles?.completedOnboarding;
+    }
+};
+export function transformMember(bot, payload, extra) {
+    const member = Object.create(baseMember);
+    const props = bot.transformers.desiredProperties.member;
+    if (props.id && extra?.userId) member.id = typeof extra.userId === 'string' ? bot.transformers.snowflake(extra.userId) : extra.userId;
+    if (props.guildId && extra?.guildId) member.guildId = typeof extra.guildId === 'string' ? bot.transformers.snowflake(extra.guildId) : extra.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.banner && payload.banner) member.banner = iconHashToBigInt(payload.banner);
+    if (props.permissions && payload.permissions) member.permissions = new Permissions(payload.permissions);
+    if (props.toggles) 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, {
+        guildId: extra?.guildId ? bot.transformers.snowflake(extra.guildId) : undefined,
+        userId: extra?.userId ? bot.transformers.snowflake(extra.userId) : undefined
+    });
+}
+
+//# 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 { DesiredPropertiesBehavior, SetupDesiredProps, TransformersDesiredProperties } from '../index.js'\nimport { MemberToggles } from './toggles/member.js'\nimport { Permissions } from './toggles/Permissions.js'\nimport type { Member } from './types.js'\n\nexport const baseMember: Member = {\n  // This allows typescript to still check for type errors on functions below\n  ...(undefined as unknown as Member),\n\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  get flags() {\n    return this.toggles?.flags ?? 0\n  },\n  get didRejoin() {\n    return !!this.toggles?.didRejoin\n  },\n  get startedOnboarding() {\n    return !!this.toggles?.startedOnboarding\n  },\n  get bypassesVerification() {\n    return !!this.toggles?.bypassesVerification\n  },\n  get completedOnboarding() {\n    return !!this.toggles?.completedOnboarding\n  },\n}\n\nexport function transformMember(bot: Bot, payload: DiscordMember, extra?: { guildId?: BigString; userId?: BigString }): Member {\n  const member: SetupDesiredProps<Member, TransformersDesiredProperties, DesiredPropertiesBehavior> = Object.create(baseMember)\n  const props = bot.transformers.desiredProperties.member\n\n  if (props.id && extra?.userId) member.id = typeof extra.userId === 'string' ? bot.transformers.snowflake(extra.userId) : extra.userId\n  if (props.guildId && extra?.guildId) member.guildId = typeof extra.guildId === 'string' ? bot.transformers.snowflake(extra.guildId) : extra.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.banner && payload.banner) member.banner = iconHashToBigInt(payload.banner)\n  if (props.permissions && payload.permissions) member.permissions = new Permissions(payload.permissions)\n  if (props.toggles) member.toggles = new MemberToggles(payload)\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    guildId: extra?.guildId ? bot.transformers.snowflake(extra.guildId) : undefined,\n    userId: extra?.userId ? bot.transformers.snowflake(extra.userId) : undefined,\n  })\n}\n"],"names":["iconHashToBigInt","MemberToggles","Permissions","baseMember","undefined","deaf","toggles","has","mute","pending","flags","didRejoin","startedOnboarding","bypassesVerification","completedOnboarding","transformMember","bot","payload","extra","member","Object","create","props","transformers","desiredProperties","id","userId","snowflake","guildId","user","nick","roles","map","joinedAt","joined_at","Date","parse","premiumSince","premium_since","communicationDisabledUntil","communication_disabled_until","avatar","banner","permissions","avatarDecorationData","avatar_decoration_data","customizers"],"mappings":"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"}

package/dist/transformers/message.d.ts

@@ -0,0 +1,15 @@
+import { type DiscordMessage, type DiscordMessageCall, type DiscordMessageInteractionMetadata, type DiscordMessagePin, type DiscordMessageSnapshot } from '@discordeno/types';
+import { type Bot, type Message, type MessageCall, type MessageInteractionMetadata, type MessagePin, type MessageSnapshot } from '../index.js';
+export declare const baseMessage: Message;
+export declare function transformMessage(bot: Bot, payload: DiscordMessage, extra?: {
+    shardId?: number;
+}): Message;
+export declare function transformMessagePin(bot: Bot, payload: DiscordMessagePin, extra?: {
+    shardId?: number;
+}): MessagePin;
+export declare function transformMessageSnapshot(bot: Bot, payload: DiscordMessageSnapshot, extra?: {
+    shardId?: number;
+}): MessageSnapshot;
+export declare function transformMessageInteractionMetadata(bot: Bot, payload: DiscordMessageInteractionMetadata): MessageInteractionMetadata;
+export declare function transformMessageCall(bot: Bot, payload: DiscordMessageCall): MessageCall;
+//# sourceMappingURL=message.d.ts.map

package/dist/transformers/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/transformers/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,iCAAiC,EACtC,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAE5B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,KAAK,GAAG,EAER,KAAK,OAAO,EACZ,KAAK,WAAW,EAEhB,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,eAAe,EAIrB,MAAM,aAAa,CAAA;AAKpB,eAAO,MAAM,WAAW,EAAE,OAkHzB,CAAA;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAqHzG;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAQlH;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,sBAAsB,EAAE,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,CASjI;AAED,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,iCAAiC,GAAG,0BAA0B,CAqCpI;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAQvF"}