@discordeno/bot 19.0.0-next.fd357ae → 19.0.0-next.fda3003

package/dist/esm/transformers/toggles/guild.js

@@ -0,0 +1,206 @@
+import { GuildFeatures } from '@discordeno/types';
+import { ToggleBitfieldBigint } from './ToggleBitfield.js';
+const featureNames = [
+    'inviteSplash',
+    'vipRegions',
+    'vanityUrl',
+    'verified',
+    'partnered',
+    'community',
+    'developerSupportServer',
+    'news',
+    'discoverable',
+    'featurable',
+    'animatedIcon',
+    'banner',
+    'welcomeScreenEnabled',
+    'memberVerificationGateEnabled',
+    'previewEnabled',
+    'ticketedEventsEnabled',
+    'monetizationEnabled',
+    'moreStickers',
+    'roleIcons',
+    'autoModeration',
+    'invitesDisabled',
+    'animatedBanner'
+];
+export const GuildToggle = {
+    /** Whether the bot is the owner of the guild */ owner: 1n << 0n,
+    /** Whether the server widget is enabled */ widgetEnabled: 1n << 1n,
+    /** Whether this is considered a large guild */ large: 1n << 2n,
+    /** Whether this guild is unavailable due to an outage */ unavailable: 1n << 3n,
+    /** Whether the guild has the boost progress bar enabled */ premiumProgressBarEnabled: 1n << 4n,
+    // GUILD FEATURES ARE BELOW THIS
+    /** Whether the guild has access to set an invite splash background */ inviteSplash: 1n << 5n,
+    /** Whether the guild has access to set 384 kbps bitrate in voice (previously VIP voice servers) */ vipRegions: 1n << 6n,
+    /** Whether the guild has access to set a vanity URL */ vanityUrl: 1n << 7n,
+    /** Whether the guild is verified */ verified: 1n << 8n,
+    /** Whether the guild is partnered */ partnered: 1n << 9n,
+    /** Whether the guild can enable welcome screen, Membership Screening, stage channels and discovery, and receives community updates */ community: 1n << 10n,
+    /** Whether the guild has enabled monetization. */ creatorMonetizableProvisional: 1n << 31n,
+    /** Whether the guild has enabled the role subscription promo page. */ creatorStorePage: 1n << 32n,
+    /** Whether the guild has access to set an animated guild banner image */ animatedBanner: 1n << 11n,
+    /** Whether the guild has access to create news channels */ news: 1n << 12n,
+    /** Whether the guild is able to be discovered in the directory */ discoverable: 1n << 13n,
+    /** Whether the guild is able to be featured in the directory */ featurable: 1n << 15n,
+    /** Whether the guild has access to set an animated guild icon */ animatedIcon: 1n << 16n,
+    /** Whether the guild has access to set a guild banner image */ banner: 1n << 17n,
+    /** Whether the guild has enabled the welcome screen */ welcomeScreenEnabled: 1n << 18n,
+    /** Whether the guild has enabled [Membership Screening](https://discord.com/developers/docs/resources/guild#membership-screening-object) */ memberVerificationGateEnabled: 1n << 19n,
+    /** Whether the guild can be previewed before joining via Membership Screening or the directory */ previewEnabled: 1n << 20n,
+    /** Whether the guild has enabled ticketed events */ ticketedEventsEnabled: 1n << 21n,
+    /** Whether the guild has enabled monetization */ monetizationEnabled: 1n << 22n,
+    /** Whether the guild has increased custom sticker slots */ moreStickers: 1n << 23n,
+    /** Whether the guild is able to set role icons */ roleIcons: 1n << 27n,
+    /** Whether the guild has role subscriptions that can be purchased. */ roleSubscriptionsAvailableForPurchase: 1n << 33n,
+    /** Whether the guild has enabled role subscriptions. */ roleSubscriptionsEnabled: 1n << 34n,
+    /** Whether the guild has set up auto moderation rules */ autoModeration: 1n << 28n,
+    /** Whether the guild has paused invites, preventing new users from joining */ invitesDisabled: 1n << 29n,
+    /** Whether the guild has been set as a support server on the App Directory */ developerSupportServer: 1n << 30n
+};
+export class GuildToggles extends ToggleBitfieldBigint {
+    constructor(guildOrTogglesBigint){
+        super();
+        if (typeof guildOrTogglesBigint === 'bigint') this.bitfield = guildOrTogglesBigint;
+        else {
+            const guild = guildOrTogglesBigint;
+            // Cause discord be smart like that
+            if (!guild.features) guild.features = [];
+            if (guild.owner) this.add(GuildToggle.owner);
+            if (guild.widget_enabled) this.add(GuildToggle.widgetEnabled);
+            if (guild.large) this.add(GuildToggle.large);
+            if (guild.unavailable) this.add(GuildToggle.unavailable);
+            if (guild.premium_progress_bar_enabled) this.add(GuildToggle.premiumProgressBarEnabled);
+            if (guild.features.includes(GuildFeatures.InviteSplash)) this.add(GuildToggle.inviteSplash);
+            if (guild.features.includes(GuildFeatures.VipRegions)) this.add(GuildToggle.vipRegions);
+            if (guild.features.includes(GuildFeatures.VanityUrl)) this.add(GuildToggle.vanityUrl);
+            if (guild.features.includes(GuildFeatures.Verified)) this.add(GuildToggle.verified);
+            if (guild.features.includes(GuildFeatures.Partnered)) this.add(GuildToggle.partnered);
+            if (guild.features.includes(GuildFeatures.Community)) this.add(GuildToggle.community);
+            if (guild.features.includes(GuildFeatures.CreatorMonetizableProvisional)) this.add(GuildToggle.creatorMonetizableProvisional);
+            if (guild.features.includes(GuildFeatures.CreatorStorePage)) this.add(GuildToggle.creatorStorePage);
+            if (guild.features.includes(GuildFeatures.DeveloperSupportServer)) this.add(GuildToggle.developerSupportServer);
+            if (guild.features.includes(GuildFeatures.AnimatedBanner)) this.add(GuildToggle.animatedBanner);
+            if (guild.features.includes(GuildFeatures.News)) this.add(GuildToggle.news);
+            if (guild.features.includes(GuildFeatures.Discoverable)) this.add(GuildToggle.discoverable);
+            if (guild.features.includes(GuildFeatures.Featurable)) this.add(GuildToggle.featurable);
+            if (guild.features.includes(GuildFeatures.AnimatedIcon)) this.add(GuildToggle.animatedIcon);
+            if (guild.features.includes(GuildFeatures.Banner)) this.add(GuildToggle.banner);
+            if (guild.features.includes(GuildFeatures.WelcomeScreenEnabled)) this.add(GuildToggle.welcomeScreenEnabled);
+            if (guild.features.includes(GuildFeatures.MemberVerificationGateEnabled)) {
+                this.add(GuildToggle.memberVerificationGateEnabled);
+            }
+            if (guild.features.includes(GuildFeatures.PreviewEnabled)) this.add(GuildToggle.previewEnabled);
+            if (guild.features.includes(GuildFeatures.TicketedEventsEnabled)) this.add(GuildToggle.ticketedEventsEnabled);
+            if (guild.features.includes(GuildFeatures.MoreStickers)) this.add(GuildToggle.moreStickers);
+            if (guild.features.includes(GuildFeatures.RoleIcons)) this.add(GuildToggle.roleIcons);
+            if (guild.features.includes(GuildFeatures.RoleSubscriptionsAvailableForPurchase)) this.add(GuildToggle.roleSubscriptionsAvailableForPurchase);
+            if (guild.features.includes(GuildFeatures.RoleSubscriptionsEnabled)) this.add(GuildToggle.roleSubscriptionsEnabled);
+            if (guild.features.includes(GuildFeatures.AutoModeration)) this.add(GuildToggle.autoModeration);
+            if (guild.features.includes(GuildFeatures.InvitesDisabled)) this.add(GuildToggle.invitesDisabled);
+        }
+    }
+    get features() {
+        const features = [];
+        for (const key of Object.keys(GuildToggle)){
+            if (!featureNames.includes(key)) continue;
+            if (!super.contains(GuildToggle[key])) continue;
+            features.push(key);
+        }
+        return features;
+    }
+    /** Whether the bot is the owner of the guild */ get owner() {
+        return this.has('owner');
+    }
+    /** Whether the server widget is enabled */ get widgetEnabled() {
+        return this.has('widgetEnabled');
+    }
+    /** Whether this is considered a large guild */ get large() {
+        return this.has('large');
+    }
+    /** Whether this guild is unavailable due to an outage */ get unavailable() {
+        return this.has('unavailable');
+    }
+    /** Whether the guild has the boost progress bar enabled */ get premiumProgressBarEnabled() {
+        return this.has('premiumProgressBarEnabled');
+    }
+    /** Whether the guild has access to set an invite splash background */ get inviteSplash() {
+        return this.has('inviteSplash');
+    }
+    /** Whether the guild has access to set 384 kbps bitrate in voice (previously VIP voice servers) */ get vipRegions() {
+        return this.has('vipRegions');
+    }
+    /** Whether the guild has access to set a vanity URL */ get vanityUrl() {
+        return this.has('vanityUrl');
+    }
+    /** Whether the guild is verified */ get verified() {
+        return this.has('verified');
+    }
+    /** Whether the guild is partnered */ get partnered() {
+        return this.has('partnered');
+    }
+    /** Whether the guild can enable welcome screen, Membership Screening, stage channels and discovery, and receives community updates */ get community() {
+        return this.has('community');
+    }
+    /** Whether the Guild has been set as a support server on the App Directory */ get developerSupportServer() {
+        return this.has('developerSupportServer');
+    }
+    /** Whether the guild has access to set an animated guild banner image */ get animatedBanner() {
+        return this.has('animatedBanner');
+    }
+    /** Whether the guild has access to create news channels */ get news() {
+        return this.has('news');
+    }
+    /** Whether the guild is able to be discovered in the directory */ get discoverable() {
+        return this.has('discoverable');
+    }
+    /** Whether the guild is able to be featured in the directory */ get featurable() {
+        return this.has('featurable');
+    }
+    /** Whether the guild has access to set an animated guild icon */ get animatedIcon() {
+        return this.has('animatedIcon');
+    }
+    /** Whether the guild has access to set a guild banner image */ get banner() {
+        return this.has('banner');
+    }
+    /** Whether the guild has enabled the welcome screen */ get welcomeScreenEnabled() {
+        return this.has('welcomeScreenEnabled');
+    }
+    /** Whether the guild has enabled [Membership Screening](https://discord.com/developers/docs/resources/guild#membership-screening-object) */ get memberVerificationGateEnabled() {
+        return this.has('memberVerificationGateEnabled');
+    }
+    /** Whether the guild can be previewed before joining via Membership Screening or the directory */ get previewEnabled() {
+        return this.has('previewEnabled');
+    }
+    /** Whether the guild has enabled ticketed events */ get ticketedEventsEnabled() {
+        return this.has('ticketedEventsEnabled');
+    }
+    /** Whether the guild has enabled monetization */ get monetizationEnabled() {
+        return this.has('monetizationEnabled');
+    }
+    /** Whether the guild has increased custom sticker slots */ get moreStickers() {
+        return this.has('moreStickers');
+    }
+    /** Whether the guild is able to set role icons */ get roleIcons() {
+        return this.has('roleIcons');
+    }
+    /** Whether the guild has set up auto moderation rules */ get autoModeration() {
+        return this.has('autoModeration');
+    }
+    /** Whether the guild has paused invites, preventing new users from joining */ get invitesDisabled() {
+        return this.has('invitesDisabled');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(GuildToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= GuildToggle[b], 0n));
+    }
+    /** Lists all the toggles for the role and whether or not each is true or false. */ list() {
+        const json = {};
+        for (const [key, value] of Object.entries(GuildToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/transformers/toggles/guild.ts"],"sourcesContent":["import { GuildFeatures, type DiscordGuild } from '@discordeno/types'\nimport { ToggleBitfieldBigint } from './ToggleBitfield.js'\n\nconst featureNames = [\n  'inviteSplash',\n  'vipRegions',\n  'vanityUrl',\n  'verified',\n  'partnered',\n  'community',\n  'developerSupportServer',\n  'news',\n  'discoverable',\n  'featurable',\n  'animatedIcon',\n  'banner',\n  'welcomeScreenEnabled',\n  'memberVerificationGateEnabled',\n  'previewEnabled',\n  'ticketedEventsEnabled',\n  'monetizationEnabled',\n  'moreStickers',\n  'roleIcons',\n  'autoModeration',\n  'invitesDisabled',\n  'animatedBanner',\n]\n\nexport const GuildToggle = {\n  /** Whether the bot is the owner of the guild */\n  owner: 1n << 0n,\n  /** Whether the server widget is enabled */\n  widgetEnabled: 1n << 1n,\n  /** Whether this is considered a large guild */\n  large: 1n << 2n,\n  /** Whether this guild is unavailable due to an outage */\n  unavailable: 1n << 3n,\n  /** Whether the guild has the boost progress bar enabled */\n  premiumProgressBarEnabled: 1n << 4n,\n\n  // GUILD FEATURES ARE BELOW THIS\n\n  /** Whether the guild has access to set an invite splash background */\n  inviteSplash: 1n << 5n,\n  /** Whether the guild has access to set 384 kbps bitrate in voice (previously VIP voice servers) */\n  vipRegions: 1n << 6n,\n  /** Whether the guild has access to set a vanity URL */\n  vanityUrl: 1n << 7n,\n  /** Whether the guild is verified */\n  verified: 1n << 8n,\n  /** Whether the guild is partnered */\n  partnered: 1n << 9n,\n  /** Whether the guild can enable welcome screen, Membership Screening, stage channels and discovery, and receives community updates */\n  community: 1n << 10n,\n  /** Whether the guild has enabled monetization. */\n  creatorMonetizableProvisional: 1n << 31n,\n  /** Whether the guild has enabled the role subscription promo page. */\n  creatorStorePage: 1n << 32n,\n  /** Whether the guild has access to set an animated guild banner image */\n  animatedBanner: 1n << 11n,\n  /** Whether the guild has access to create news channels */\n  news: 1n << 12n,\n  /** Whether the guild is able to be discovered in the directory */\n  discoverable: 1n << 13n,\n  /** Whether the guild is able to be featured in the directory */\n  featurable: 1n << 15n,\n  /** Whether the guild has access to set an animated guild icon */\n  animatedIcon: 1n << 16n,\n  /** Whether the guild has access to set a guild banner image */\n  banner: 1n << 17n,\n  /** Whether the guild has enabled the welcome screen */\n  welcomeScreenEnabled: 1n << 18n,\n  /** Whether the guild has enabled [Membership Screening](https://discord.com/developers/docs/resources/guild#membership-screening-object) */\n  memberVerificationGateEnabled: 1n << 19n,\n  /** Whether the guild can be previewed before joining via Membership Screening or the directory */\n  previewEnabled: 1n << 20n,\n  /** Whether the guild has enabled ticketed events */\n  ticketedEventsEnabled: 1n << 21n,\n  /** Whether the guild has enabled monetization */\n  monetizationEnabled: 1n << 22n,\n  /** Whether the guild has increased custom sticker slots */\n  moreStickers: 1n << 23n,\n  /** Whether the guild is able to set role icons */\n  roleIcons: 1n << 27n,\n  /** Whether the guild has role subscriptions that can be purchased. */\n  roleSubscriptionsAvailableForPurchase: 1n << 33n,\n  /** Whether the guild has enabled role subscriptions. */\n  roleSubscriptionsEnabled: 1n << 34n,\n  /** Whether the guild has set up auto moderation rules */\n  autoModeration: 1n << 28n,\n  /** Whether the guild has paused invites, preventing new users from joining */\n  invitesDisabled: 1n << 29n,\n  /** Whether the guild has been set as a support server on the App Directory */\n  developerSupportServer: 1n << 30n,\n}\n\nexport class GuildToggles extends ToggleBitfieldBigint {\n  constructor(guildOrTogglesBigint: DiscordGuild | bigint) {\n    super()\n\n    if (typeof guildOrTogglesBigint === 'bigint') this.bitfield = guildOrTogglesBigint\n    else {\n      const guild = guildOrTogglesBigint\n      // Cause discord be smart like that\n      if (!guild.features) guild.features = []\n\n      if (guild.owner) this.add(GuildToggle.owner)\n      if (guild.widget_enabled) this.add(GuildToggle.widgetEnabled)\n      if (guild.large) this.add(GuildToggle.large)\n      if (guild.unavailable) this.add(GuildToggle.unavailable)\n      if (guild.premium_progress_bar_enabled) this.add(GuildToggle.premiumProgressBarEnabled)\n\n      if (guild.features.includes(GuildFeatures.InviteSplash)) this.add(GuildToggle.inviteSplash)\n      if (guild.features.includes(GuildFeatures.VipRegions)) this.add(GuildToggle.vipRegions)\n      if (guild.features.includes(GuildFeatures.VanityUrl)) this.add(GuildToggle.vanityUrl)\n      if (guild.features.includes(GuildFeatures.Verified)) this.add(GuildToggle.verified)\n      if (guild.features.includes(GuildFeatures.Partnered)) this.add(GuildToggle.partnered)\n      if (guild.features.includes(GuildFeatures.Community)) this.add(GuildToggle.community)\n      if (guild.features.includes(GuildFeatures.CreatorMonetizableProvisional)) this.add(GuildToggle.creatorMonetizableProvisional)\n      if (guild.features.includes(GuildFeatures.CreatorStorePage)) this.add(GuildToggle.creatorStorePage)\n      if (guild.features.includes(GuildFeatures.DeveloperSupportServer)) this.add(GuildToggle.developerSupportServer)\n      if (guild.features.includes(GuildFeatures.AnimatedBanner)) this.add(GuildToggle.animatedBanner)\n      if (guild.features.includes(GuildFeatures.News)) this.add(GuildToggle.news)\n      if (guild.features.includes(GuildFeatures.Discoverable)) this.add(GuildToggle.discoverable)\n      if (guild.features.includes(GuildFeatures.Featurable)) this.add(GuildToggle.featurable)\n      if (guild.features.includes(GuildFeatures.AnimatedIcon)) this.add(GuildToggle.animatedIcon)\n      if (guild.features.includes(GuildFeatures.Banner)) this.add(GuildToggle.banner)\n      if (guild.features.includes(GuildFeatures.WelcomeScreenEnabled)) this.add(GuildToggle.welcomeScreenEnabled)\n      if (guild.features.includes(GuildFeatures.MemberVerificationGateEnabled)) {\n        this.add(GuildToggle.memberVerificationGateEnabled)\n      }\n      if (guild.features.includes(GuildFeatures.PreviewEnabled)) this.add(GuildToggle.previewEnabled)\n      if (guild.features.includes(GuildFeatures.TicketedEventsEnabled)) this.add(GuildToggle.ticketedEventsEnabled)\n      if (guild.features.includes(GuildFeatures.MoreStickers)) this.add(GuildToggle.moreStickers)\n      if (guild.features.includes(GuildFeatures.RoleIcons)) this.add(GuildToggle.roleIcons)\n      if (guild.features.includes(GuildFeatures.RoleSubscriptionsAvailableForPurchase)) this.add(GuildToggle.roleSubscriptionsAvailableForPurchase)\n      if (guild.features.includes(GuildFeatures.RoleSubscriptionsEnabled)) this.add(GuildToggle.roleSubscriptionsEnabled)\n      if (guild.features.includes(GuildFeatures.AutoModeration)) this.add(GuildToggle.autoModeration)\n      if (guild.features.includes(GuildFeatures.InvitesDisabled)) this.add(GuildToggle.invitesDisabled)\n    }\n  }\n\n  get features(): GuildToggleKeys[] {\n    const features: GuildToggleKeys[] = []\n    for (const key of Object.keys(GuildToggle)) {\n      if (!featureNames.includes(key)) continue\n      if (!super.contains(GuildToggle[key as GuildToggleKeys])) continue\n\n      features.push(key as GuildToggleKeys)\n    }\n\n    return features\n  }\n\n  /** Whether the bot is the owner of the guild */\n  get owner(): boolean {\n    return this.has('owner')\n  }\n\n  /** Whether the server widget is enabled */\n  get widgetEnabled(): boolean {\n    return this.has('widgetEnabled')\n  }\n\n  /** Whether this is considered a large guild */\n  get large(): boolean {\n    return this.has('large')\n  }\n\n  /** Whether this guild is unavailable due to an outage */\n  get unavailable(): boolean {\n    return this.has('unavailable')\n  }\n\n  /** Whether the guild has the boost progress bar enabled */\n  get premiumProgressBarEnabled(): boolean {\n    return this.has('premiumProgressBarEnabled')\n  }\n\n  /** Whether the guild has access to set an invite splash background */\n  get inviteSplash(): boolean {\n    return this.has('inviteSplash')\n  }\n\n  /** Whether the guild has access to set 384 kbps bitrate in voice (previously VIP voice servers) */\n  get vipRegions(): boolean {\n    return this.has('vipRegions')\n  }\n\n  /** Whether the guild has access to set a vanity URL */\n  get vanityUrl(): boolean {\n    return this.has('vanityUrl')\n  }\n\n  /** Whether the guild is verified */\n  get verified(): boolean {\n    return this.has('verified')\n  }\n\n  /** Whether the guild is partnered */\n  get partnered(): boolean {\n    return this.has('partnered')\n  }\n\n  /** Whether the guild can enable welcome screen, Membership Screening, stage channels and discovery, and receives community updates */\n  get community(): boolean {\n    return this.has('community')\n  }\n\n  /** Whether the Guild has been set as a support server on the App Directory */\n  get developerSupportServer(): boolean {\n    return this.has('developerSupportServer')\n  }\n\n  /** Whether the guild has access to set an animated guild banner image */\n  get animatedBanner(): boolean {\n    return this.has('animatedBanner')\n  }\n\n  /** Whether the guild has access to create news channels */\n  get news(): boolean {\n    return this.has('news')\n  }\n\n  /** Whether the guild is able to be discovered in the directory */\n  get discoverable(): boolean {\n    return this.has('discoverable')\n  }\n\n  /** Whether the guild is able to be featured in the directory */\n  get featurable(): boolean {\n    return this.has('featurable')\n  }\n\n  /** Whether the guild has access to set an animated guild icon */\n  get animatedIcon(): boolean {\n    return this.has('animatedIcon')\n  }\n\n  /** Whether the guild has access to set a guild banner image */\n  get banner(): boolean {\n    return this.has('banner')\n  }\n\n  /** Whether the guild has enabled the welcome screen */\n  get welcomeScreenEnabled(): boolean {\n    return this.has('welcomeScreenEnabled')\n  }\n\n  /** Whether the guild has enabled [Membership Screening](https://discord.com/developers/docs/resources/guild#membership-screening-object) */\n  get memberVerificationGateEnabled(): boolean {\n    return this.has('memberVerificationGateEnabled')\n  }\n\n  /** Whether the guild can be previewed before joining via Membership Screening or the directory */\n  get previewEnabled(): boolean {\n    return this.has('previewEnabled')\n  }\n\n  /** Whether the guild has enabled ticketed events */\n  get ticketedEventsEnabled(): boolean {\n    return this.has('ticketedEventsEnabled')\n  }\n\n  /** Whether the guild has enabled monetization */\n  get monetizationEnabled(): boolean {\n    return this.has('monetizationEnabled')\n  }\n\n  /** Whether the guild has increased custom sticker slots */\n  get moreStickers(): boolean {\n    return this.has('moreStickers')\n  }\n\n  /** Whether the guild is able to set role icons */\n  get roleIcons(): boolean {\n    return this.has('roleIcons')\n  }\n\n  /** Whether the guild has set up auto moderation rules */\n  get autoModeration(): boolean {\n    return this.has('autoModeration')\n  }\n\n  /** Whether the guild has paused invites, preventing new users from joining */\n  get invitesDisabled(): boolean {\n    return this.has('invitesDisabled')\n  }\n\n  /** Checks whether or not the permissions exist in this */\n  has(permissions: GuildToggleKeys | GuildToggleKeys[]): boolean {\n    if (!Array.isArray(permissions)) return super.contains(GuildToggle[permissions])\n\n    return super.contains(permissions.reduce((a, b) => (a |= GuildToggle[b]), 0n))\n  }\n\n  /** Lists all the toggles for the role and whether or not each is true or false. */\n  list(): Record<GuildToggleKeys, boolean> {\n    const json: Record<string, boolean> = {}\n    for (const [key, value] of Object.entries(GuildToggle)) {\n      json[key] = super.contains(value)\n    }\n\n    return json as Record<GuildToggleKeys, boolean>\n  }\n}\n\nexport type GuildToggleKeys = keyof typeof GuildToggle\n"],"names":["GuildFeatures","ToggleBitfieldBigint","featureNames","GuildToggle","owner","widgetEnabled","large","unavailable","premiumProgressBarEnabled","inviteSplash","vipRegions","vanityUrl","verified","partnered","community","creatorMonetizableProvisional","creatorStorePage","animatedBanner","news","discoverable","featurable","animatedIcon","banner","welcomeScreenEnabled","memberVerificationGateEnabled","previewEnabled","ticketedEventsEnabled","monetizationEnabled","moreStickers","roleIcons","roleSubscriptionsAvailableForPurchase","roleSubscriptionsEnabled","autoModeration","invitesDisabled","developerSupportServer","GuildToggles","constructor","guildOrTogglesBigint","bitfield","guild","features","add","widget_enabled","premium_progress_bar_enabled","includes","InviteSplash","VipRegions","VanityUrl","Verified","Partnered","Community","CreatorMonetizableProvisional","CreatorStorePage","DeveloperSupportServer","AnimatedBanner","News","Discoverable","Featurable","AnimatedIcon","Banner","WelcomeScreenEnabled","MemberVerificationGateEnabled","PreviewEnabled","TicketedEventsEnabled","MoreStickers","RoleIcons","RoleSubscriptionsAvailableForPurchase","RoleSubscriptionsEnabled","AutoModeration","InvitesDisabled","key","Object","keys","contains","push","has","permissions","Array","isArray","reduce","a","b","list","json","value","entries"],"mappings":"AAAA,SAASA,aAAa,QAA2B,oBAAmB;AACpE,SAASC,oBAAoB,QAAQ,sBAAqB;AAE1D,MAAMC,eAAe;IACnB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAED,OAAO,MAAMC,cAAc;IACzB,8CAA8C,GAC9CC,OAAO,EAAE,IAAI,EAAE;IACf,yCAAyC,GACzCC,eAAe,EAAE,IAAI,EAAE;IACvB,6CAA6C,GAC7CC,OAAO,EAAE,IAAI,EAAE;IACf,uDAAuD,GACvDC,aAAa,EAAE,IAAI,EAAE;IACrB,yDAAyD,GACzDC,2BAA2B,EAAE,IAAI,EAAE;IAEnC,gCAAgC;IAEhC,oEAAoE,GACpEC,cAAc,EAAE,IAAI,EAAE;IACtB,iGAAiG,GACjGC,YAAY,EAAE,IAAI,EAAE;IACpB,qDAAqD,GACrDC,WAAW,EAAE,IAAI,EAAE;IACnB,kCAAkC,GAClCC,UAAU,EAAE,IAAI,EAAE;IAClB,mCAAmC,GACnCC,WAAW,EAAE,IAAI,EAAE;IACnB,oIAAoI,GACpIC,WAAW,EAAE,IAAI,GAAG;IACpB,gDAAgD,GAChDC,+BAA+B,EAAE,IAAI,GAAG;IACxC,oEAAoE,GACpEC,kBAAkB,EAAE,IAAI,GAAG;IAC3B,uEAAuE,GACvEC,gBAAgB,EAAE,IAAI,GAAG;IACzB,yDAAyD,GACzDC,MAAM,EAAE,IAAI,GAAG;IACf,gEAAgE,GAChEC,cAAc,EAAE,IAAI,GAAG;IACvB,8DAA8D,GAC9DC,YAAY,EAAE,IAAI,GAAG;IACrB,+DAA+D,GAC/DC,cAAc,EAAE,IAAI,GAAG;IACvB,6DAA6D,GAC7DC,QAAQ,EAAE,IAAI,GAAG;IACjB,qDAAqD,GACrDC,sBAAsB,EAAE,IAAI,GAAG;IAC/B,0IAA0I,GAC1IC,+BAA+B,EAAE,IAAI,GAAG;IACxC,gGAAgG,GAChGC,gBAAgB,EAAE,IAAI,GAAG;IACzB,kDAAkD,GAClDC,uBAAuB,EAAE,IAAI,GAAG;IAChC,+CAA+C,GAC/CC,qBAAqB,EAAE,IAAI,GAAG;IAC9B,yDAAyD,GACzDC,cAAc,EAAE,IAAI,GAAG;IACvB,gDAAgD,GAChDC,WAAW,EAAE,IAAI,GAAG;IACpB,oEAAoE,GACpEC,uCAAuC,EAAE,IAAI,GAAG;IAChD,sDAAsD,GACtDC,0BAA0B,EAAE,IAAI,GAAG;IACnC,uDAAuD,GACvDC,gBAAgB,EAAE,IAAI,GAAG;IACzB,4EAA4E,GAC5EC,iBAAiB,EAAE,IAAI,GAAG;IAC1B,4EAA4E,GAC5EC,wBAAwB,EAAE,IAAI,GAAG;AACnC,EAAC;AAED,OAAO,MAAMC,qBAAqBlC;IAChCmC,YAAYC,oBAA2C,CAAE;QACvD,KAAK;QAEL,IAAI,OAAOA,yBAAyB,UAAU,IAAI,CAACC,QAAQ,GAAGD;aACzD;YACH,MAAME,QAAQF;YACd,mCAAmC;YACnC,IAAI,CAACE,MAAMC,QAAQ,EAAED,MAAMC,QAAQ,GAAG,EAAE;YAExC,IAAID,MAAMnC,KAAK,EAAE,IAAI,CAACqC,GAAG,CAACtC,YAAYC,KAAK;YAC3C,IAAImC,MAAMG,cAAc,EAAE,IAAI,CAACD,GAAG,CAACtC,YAAYE,aAAa;YAC5D,IAAIkC,MAAMjC,KAAK,EAAE,IAAI,CAACmC,GAAG,CAACtC,YAAYG,KAAK;YAC3C,IAAIiC,MAAMhC,WAAW,EAAE,IAAI,CAACkC,GAAG,CAACtC,YAAYI,WAAW;YACvD,IAAIgC,MAAMI,4BAA4B,EAAE,IAAI,CAACF,GAAG,CAACtC,YAAYK,yBAAyB;YAEtF,IAAI+B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc6C,YAAY,GAAG,IAAI,CAACJ,GAAG,CAACtC,YAAYM,YAAY;YAC1F,IAAI8B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc8C,UAAU,GAAG,IAAI,CAACL,GAAG,CAACtC,YAAYO,UAAU;YACtF,IAAI6B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc+C,SAAS,GAAG,IAAI,CAACN,GAAG,CAACtC,YAAYQ,SAAS;YACpF,IAAI4B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcgD,QAAQ,GAAG,IAAI,CAACP,GAAG,CAACtC,YAAYS,QAAQ;YAClF,IAAI2B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAciD,SAAS,GAAG,IAAI,CAACR,GAAG,CAACtC,YAAYU,SAAS;YACpF,IAAI0B,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAckD,SAAS,GAAG,IAAI,CAACT,GAAG,CAACtC,YAAYW,SAAS;YACpF,IAAIyB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcmD,6BAA6B,GAAG,IAAI,CAACV,GAAG,CAACtC,YAAYY,6BAA6B;YAC5H,IAAIwB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcoD,gBAAgB,GAAG,IAAI,CAACX,GAAG,CAACtC,YAAYa,gBAAgB;YAClG,IAAIuB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcqD,sBAAsB,GAAG,IAAI,CAACZ,GAAG,CAACtC,YAAY+B,sBAAsB;YAC9G,IAAIK,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcsD,cAAc,GAAG,IAAI,CAACb,GAAG,CAACtC,YAAYc,cAAc;YAC9F,IAAIsB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcuD,IAAI,GAAG,IAAI,CAACd,GAAG,CAACtC,YAAYe,IAAI;YAC1E,IAAIqB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcwD,YAAY,GAAG,IAAI,CAACf,GAAG,CAACtC,YAAYgB,YAAY;YAC1F,IAAIoB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcyD,UAAU,GAAG,IAAI,CAAChB,GAAG,CAACtC,YAAYiB,UAAU;YACtF,IAAImB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc0D,YAAY,GAAG,IAAI,CAACjB,GAAG,CAACtC,YAAYkB,YAAY;YAC1F,IAAIkB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc2D,MAAM,GAAG,IAAI,CAAClB,GAAG,CAACtC,YAAYmB,MAAM;YAC9E,IAAIiB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc4D,oBAAoB,GAAG,IAAI,CAACnB,GAAG,CAACtC,YAAYoB,oBAAoB;YAC1G,IAAIgB,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc6D,6BAA6B,GAAG;gBACxE,IAAI,CAACpB,GAAG,CAACtC,YAAYqB,6BAA6B;YACpD;YACA,IAAIe,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc8D,cAAc,GAAG,IAAI,CAACrB,GAAG,CAACtC,YAAYsB,cAAc;YAC9F,IAAIc,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAc+D,qBAAqB,GAAG,IAAI,CAACtB,GAAG,CAACtC,YAAYuB,qBAAqB;YAC5G,IAAIa,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcgE,YAAY,GAAG,IAAI,CAACvB,GAAG,CAACtC,YAAYyB,YAAY;YAC1F,IAAIW,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAciE,SAAS,GAAG,IAAI,CAACxB,GAAG,CAACtC,YAAY0B,SAAS;YACpF,IAAIU,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAckE,qCAAqC,GAAG,IAAI,CAACzB,GAAG,CAACtC,YAAY2B,qCAAqC;YAC5I,IAAIS,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcmE,wBAAwB,GAAG,IAAI,CAAC1B,GAAG,CAACtC,YAAY4B,wBAAwB;YAClH,IAAIQ,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcoE,cAAc,GAAG,IAAI,CAAC3B,GAAG,CAACtC,YAAY6B,cAAc;YAC9F,IAAIO,MAAMC,QAAQ,CAACI,QAAQ,CAAC5C,cAAcqE,eAAe,GAAG,IAAI,CAAC5B,GAAG,CAACtC,YAAY8B,eAAe;QAClG;IACF;IAEA,IAAIO,WAA8B;QAChC,MAAMA,WAA8B,EAAE;QACtC,KAAK,MAAM8B,OAAOC,OAAOC,IAAI,CAACrE,aAAc;YAC1C,IAAI,CAACD,aAAa0C,QAAQ,CAAC0B,MAAM;YACjC,IAAI,CAAC,KAAK,CAACG,SAAStE,WAAW,CAACmE,IAAuB,GAAG;YAE1D9B,SAASkC,IAAI,CAACJ;QAChB;QAEA,OAAO9B;IACT;IAEA,8CAA8C,GAC9C,IAAIpC,QAAiB;QACnB,OAAO,IAAI,CAACuE,GAAG,CAAC;IAClB;IAEA,yCAAyC,GACzC,IAAItE,gBAAyB;QAC3B,OAAO,IAAI,CAACsE,GAAG,CAAC;IAClB;IAEA,6CAA6C,GAC7C,IAAIrE,QAAiB;QACnB,OAAO,IAAI,CAACqE,GAAG,CAAC;IAClB;IAEA,uDAAuD,GACvD,IAAIpE,cAAuB;QACzB,OAAO,IAAI,CAACoE,GAAG,CAAC;IAClB;IAEA,yDAAyD,GACzD,IAAInE,4BAAqC;QACvC,OAAO,IAAI,CAACmE,GAAG,CAAC;IAClB;IAEA,oEAAoE,GACpE,IAAIlE,eAAwB;QAC1B,OAAO,IAAI,CAACkE,GAAG,CAAC;IAClB;IAEA,iGAAiG,GACjG,IAAIjE,aAAsB;QACxB,OAAO,IAAI,CAACiE,GAAG,CAAC;IAClB;IAEA,qDAAqD,GACrD,IAAIhE,YAAqB;QACvB,OAAO,IAAI,CAACgE,GAAG,CAAC;IAClB;IAEA,kCAAkC,GAClC,IAAI/D,WAAoB;QACtB,OAAO,IAAI,CAAC+D,GAAG,CAAC;IAClB;IAEA,mCAAmC,GACnC,IAAI9D,YAAqB;QACvB,OAAO,IAAI,CAAC8D,GAAG,CAAC;IAClB;IAEA,oIAAoI,GACpI,IAAI7D,YAAqB;QACvB,OAAO,IAAI,CAAC6D,GAAG,CAAC;IAClB;IAEA,4EAA4E,GAC5E,IAAIzC,yBAAkC;QACpC,OAAO,IAAI,CAACyC,GAAG,CAAC;IAClB;IAEA,uEAAuE,GACvE,IAAI1D,iBAA0B;QAC5B,OAAO,IAAI,CAAC0D,GAAG,CAAC;IAClB;IAEA,yDAAyD,GACzD,IAAIzD,OAAgB;QAClB,OAAO,IAAI,CAACyD,GAAG,CAAC;IAClB;IAEA,gEAAgE,GAChE,IAAIxD,eAAwB;QAC1B,OAAO,IAAI,CAACwD,GAAG,CAAC;IAClB;IAEA,8DAA8D,GAC9D,IAAIvD,aAAsB;QACxB,OAAO,IAAI,CAACuD,GAAG,CAAC;IAClB;IAEA,+DAA+D,GAC/D,IAAItD,eAAwB;QAC1B,OAAO,IAAI,CAACsD,GAAG,CAAC;IAClB;IAEA,6DAA6D,GAC7D,IAAIrD,SAAkB;QACpB,OAAO,IAAI,CAACqD,GAAG,CAAC;IAClB;IAEA,qDAAqD,GACrD,IAAIpD,uBAAgC;QAClC,OAAO,IAAI,CAACoD,GAAG,CAAC;IAClB;IAEA,0IAA0I,GAC1I,IAAInD,gCAAyC;QAC3C,OAAO,IAAI,CAACmD,GAAG,CAAC;IAClB;IAEA,gGAAgG,GAChG,IAAIlD,iBAA0B;QAC5B,OAAO,IAAI,CAACkD,GAAG,CAAC;IAClB;IAEA,kDAAkD,GAClD,IAAIjD,wBAAiC;QACnC,OAAO,IAAI,CAACiD,GAAG,CAAC;IAClB;IAEA,+CAA+C,GAC/C,IAAIhD,sBAA+B;QACjC,OAAO,IAAI,CAACgD,GAAG,CAAC;IAClB;IAEA,yDAAyD,GACzD,IAAI/C,eAAwB;QAC1B,OAAO,IAAI,CAAC+C,GAAG,CAAC;IAClB;IAEA,gDAAgD,GAChD,IAAI9C,YAAqB;QACvB,OAAO,IAAI,CAAC8C,GAAG,CAAC;IAClB;IAEA,uDAAuD,GACvD,IAAI3C,iBAA0B;QAC5B,OAAO,IAAI,CAAC2C,GAAG,CAAC;IAClB;IAEA,4EAA4E,GAC5E,IAAI1C,kBAA2B;QAC7B,OAAO,IAAI,CAAC0C,GAAG,CAAC;IAClB;IAEA,wDAAwD,GACxDA,IAAIC,WAAgD,EAAW;QAC7D,IAAI,CAACC,MAAMC,OAAO,CAACF,cAAc,OAAO,KAAK,CAACH,SAAStE,WAAW,CAACyE,YAAY;QAE/E,OAAO,KAAK,CAACH,SAASG,YAAYG,MAAM,CAAC,CAACC,GAAGC,IAAOD,KAAK7E,WAAW,CAAC8E,EAAE,EAAG,EAAE;IAC9E;IAEA,iFAAiF,GACjFC,OAAyC;QACvC,MAAMC,OAAgC,CAAC;QACvC,KAAK,MAAM,CAACb,KAAKc,MAAM,IAAIb,OAAOc,OAAO,CAAClF,aAAc;YACtDgF,IAAI,CAACb,IAAI,GAAG,KAAK,CAACG,SAASW;QAC7B;QAEA,OAAOD;IACT;AACF"}

package/dist/esm/transformers/toggles/index.js

@@ -0,0 +1,11 @@
+export * from './channel.js';
+export * from './emoji.js';
+export * from './guild.js';
+export * from './member.js';
+export * from './Permissions.js';
+export * from './role.js';
+export * from './ToggleBitfield.js';
+export * from './user.js';
+export * from './voice.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdG9nZ2xlcy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYW5uZWwuanMnXG5leHBvcnQgKiBmcm9tICcuL2Vtb2ppLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9ndWlsZC5qcydcbmV4cG9ydCAqIGZyb20gJy4vbWVtYmVyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9QZXJtaXNzaW9ucy5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm9sZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vVG9nZ2xlQml0ZmllbGQuanMnXG5leHBvcnQgKiBmcm9tICcuL3VzZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL3ZvaWNlLmpzJ1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBYztBQUM1QixjQUFjLGFBQVk7QUFDMUIsY0FBYyxhQUFZO0FBQzFCLGNBQWMsY0FBYTtBQUMzQixjQUFjLG1CQUFrQjtBQUNoQyxjQUFjLFlBQVc7QUFDekIsY0FBYyxzQkFBcUI7QUFDbkMsY0FBYyxZQUFXO0FBQ3pCLGNBQWMsYUFBWSJ9

package/dist/esm/transformers/toggles/member.js

@@ -0,0 +1,40 @@
+import { ToggleBitfield } from './ToggleBitfield.js';
+export const MemberToggle = {
+    /** Whether the user is deafened in voice channels */ deaf: 1 << 0,
+    /** Whether the user is muted in voice channels */ mute: 1 << 1,
+    /** Whether the user has not yet passed the guild's Membership Screening requirements */ pending: 1 << 2
+};
+export class MemberToggles extends ToggleBitfield {
+    constructor(memberOrTogglesInt){
+        super();
+        if (typeof memberOrTogglesInt === 'number') this.bitfield = memberOrTogglesInt;
+        else {
+            const member = memberOrTogglesInt;
+            if (member.deaf) this.add(MemberToggle.deaf);
+            if (member.mute) this.add(MemberToggle.mute);
+            if (member.pending) this.add(MemberToggle.pending);
+        }
+    }
+    /** Whether the user belongs to an OAuth2 application */ get deaf() {
+        return this.has('deaf');
+    }
+    /** Whether the user is muted in voice channels */ get mute() {
+        return this.has('mute');
+    }
+    /** Whether the user has not yet passed the guild's Membership Screening requirements */ get pending() {
+        return this.has('pending');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(MemberToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= MemberToggle[b], 0));
+    }
+    /** Lists all the toggles for the role and whether or not each is true or false. */ list() {
+        const json = {};
+        for (const [key, value] of Object.entries(MemberToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transformers/toggles/role.js

@@ -0,0 +1,55 @@
+import { ToggleBitfield } from './ToggleBitfield.js';
+export const RoleToggle = {
+    /** If this role is showed separately in the user listing */ hoist: 1 << 0,
+    /** Whether this role is managed by an integration */ managed: 1 << 1,
+    /** Whether this role is mentionable */ mentionable: 1 << 2,
+    /** Whether this is the guilds premium subscriber role */ premiumSubscriber: 1 << 3,
+    /** Whether this role is available for purchase. */ availableForPurchase: 1 << 4,
+    /** Whether this role is available for guild connections. */ guildConnections: 1 << 5
+};
+export class RoleToggles extends ToggleBitfield {
+    constructor(roleOrTogglesInt){
+        super();
+        if (typeof roleOrTogglesInt === 'number') this.bitfield = roleOrTogglesInt;
+        else {
+            const role = roleOrTogglesInt;
+            if (role.hoist) this.add(RoleToggle.hoist);
+            if (role.managed) this.add(RoleToggle.managed);
+            if (role.mentionable) this.add(RoleToggle.mentionable);
+            if (role.tags?.premium_subscriber === null) this.add(RoleToggle.premiumSubscriber);
+            if (role.tags?.available_for_purchase === null) this.add(RoleToggle.availableForPurchase);
+            if (role.tags?.guild_connections === null) this.add(RoleToggle.guildConnections);
+        }
+    }
+    /** If this role is showed separately in the user listing */ get hoist() {
+        return this.has('hoist');
+    }
+    /** Whether this role is managed by an integration */ get managed() {
+        return this.has('managed');
+    }
+    /** Whether this role is mentionable */ get mentionable() {
+        return this.has('mentionable');
+    }
+    /** Whether this is the guilds premium subscriber role */ get premiumSubscriber() {
+        return this.has('premiumSubscriber');
+    }
+    /** Whether this role is available for purchase. */ get availableForPurchase() {
+        return this.has('availableForPurchase');
+    }
+    /** Whether this is a guild's linked role. */ get guildConnections() {
+        return this.has('guildConnections');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(RoleToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= RoleToggle[b], 0));
+    }
+    /** Lists all the toggles for the role and whether or not each is true or false. */ list() {
+        const json = {};
+        for (const [key, value] of Object.entries(RoleToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdG9nZ2xlcy9yb2xlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGlzY29yZFJvbGUgfSBmcm9tICdAZGlzY29yZGVuby90eXBlcydcbmltcG9ydCB7IFRvZ2dsZUJpdGZpZWxkIH0gZnJvbSAnLi9Ub2dnbGVCaXRmaWVsZC5qcydcblxuZXhwb3J0IGNvbnN0IFJvbGVUb2dnbGUgPSB7XG4gIC8qKiBJZiB0aGlzIHJvbGUgaXMgc2hvd2VkIHNlcGFyYXRlbHkgaW4gdGhlIHVzZXIgbGlzdGluZyAqL1xuICBob2lzdDogMSA8PCAwLFxuICAvKiogV2hldGhlciB0aGlzIHJvbGUgaXMgbWFuYWdlZCBieSBhbiBpbnRlZ3JhdGlvbiAqL1xuICBtYW5hZ2VkOiAxIDw8IDEsXG4gIC8qKiBXaGV0aGVyIHRoaXMgcm9sZSBpcyBtZW50aW9uYWJsZSAqL1xuICBtZW50aW9uYWJsZTogMSA8PCAyLFxuICAvKiogV2hldGhlciB0aGlzIGlzIHRoZSBndWlsZHMgcHJlbWl1bSBzdWJzY3JpYmVyIHJvbGUgKi9cbiAgcHJlbWl1bVN1YnNjcmliZXI6IDEgPDwgMyxcbiAgLyoqIFdoZXRoZXIgdGhpcyByb2xlIGlzIGF2YWlsYWJsZSBmb3IgcHVyY2hhc2UuICovXG4gIGF2YWlsYWJsZUZvclB1cmNoYXNlOiAxIDw8IDQsXG4gIC8qKiBXaGV0aGVyIHRoaXMgcm9sZSBpcyBhdmFpbGFibGUgZm9yIGd1aWxkIGNvbm5lY3Rpb25zLiAqL1xuICBndWlsZENvbm5lY3Rpb25zOiAxIDw8IDUsXG59XG5cbmV4cG9ydCBjbGFzcyBSb2xlVG9nZ2xlcyBleHRlbmRzIFRvZ2dsZUJpdGZpZWxkIHtcbiAgY29uc3RydWN0b3Iocm9sZU9yVG9nZ2xlc0ludDogRGlzY29yZFJvbGUgfCBudW1iZXIpIHtcbiAgICBzdXBlcigpXG5cbiAgICBpZiAodHlwZW9mIHJvbGVPclRvZ2dsZXNJbnQgPT09ICdudW1iZXInKSB0aGlzLmJpdGZpZWxkID0gcm9sZU9yVG9nZ2xlc0ludFxuICAgIGVsc2Uge1xuICAgICAgY29uc3Qgcm9sZSA9IHJvbGVPclRvZ2dsZXNJbnRcblxuICAgICAgaWYgKHJvbGUuaG9pc3QpIHRoaXMuYWRkKFJvbGVUb2dnbGUuaG9pc3QpXG4gICAgICBpZiAocm9sZS5tYW5hZ2VkKSB0aGlzLmFkZChSb2xlVG9nZ2xlLm1hbmFnZWQpXG4gICAgICBpZiAocm9sZS5tZW50aW9uYWJsZSkgdGhpcy5hZGQoUm9sZVRvZ2dsZS5tZW50aW9uYWJsZSlcbiAgICAgIGlmIChyb2xlLnRhZ3M/LnByZW1pdW1fc3Vic2NyaWJlciA9PT0gbnVsbCkgdGhpcy5hZGQoUm9sZVRvZ2dsZS5wcmVtaXVtU3Vic2NyaWJlcilcbiAgICAgIGlmIChyb2xlLnRhZ3M/LmF2YWlsYWJsZV9mb3JfcHVyY2hhc2UgPT09IG51bGwpIHRoaXMuYWRkKFJvbGVUb2dnbGUuYXZhaWxhYmxlRm9yUHVyY2hhc2UpXG4gICAgICBpZiAocm9sZS50YWdzPy5ndWlsZF9jb25uZWN0aW9ucyA9PT0gbnVsbCkgdGhpcy5hZGQoUm9sZVRvZ2dsZS5ndWlsZENvbm5lY3Rpb25zKVxuICAgIH1cbiAgfVxuXG4gIC8qKiBJZiB0aGlzIHJvbGUgaXMgc2hvd2VkIHNlcGFyYXRlbHkgaW4gdGhlIHVzZXIgbGlzdGluZyAqL1xuICBnZXQgaG9pc3QoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuaGFzKCdob2lzdCcpXG4gIH1cblxuICAvKiogV2hldGhlciB0aGlzIHJvbGUgaXMgbWFuYWdlZCBieSBhbiBpbnRlZ3JhdGlvbiAqL1xuICBnZXQgbWFuYWdlZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5oYXMoJ21hbmFnZWQnKVxuICB9XG5cbiAgLyoqIFdoZXRoZXIgdGhpcyByb2xlIGlzIG1lbnRpb25hYmxlICovXG4gIGdldCBtZW50aW9uYWJsZSgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5oYXMoJ21lbnRpb25hYmxlJylcbiAgfVxuXG4gIC8qKiBXaGV0aGVyIHRoaXMgaXMgdGhlIGd1aWxkcyBwcmVtaXVtIHN1YnNjcmliZXIgcm9sZSAqL1xuICBnZXQgcHJlbWl1bVN1YnNjcmliZXIoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuaGFzKCdwcmVtaXVtU3Vic2NyaWJlcicpXG4gIH1cblxuICAvKiogV2hldGhlciB0aGlzIHJvbGUgaXMgYXZhaWxhYmxlIGZvciBwdXJjaGFzZS4gKi9cbiAgZ2V0IGF2YWlsYWJsZUZvclB1cmNoYXNlKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmhhcygnYXZhaWxhYmxlRm9yUHVyY2hhc2UnKVxuICB9XG5cbiAgLyoqIFdoZXRoZXIgdGhpcyBpcyBhIGd1aWxkJ3MgbGlua2VkIHJvbGUuICovXG4gIGdldCBndWlsZENvbm5lY3Rpb25zKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmhhcygnZ3VpbGRDb25uZWN0aW9ucycpXG4gIH1cblxuICAvKiogQ2hlY2tzIHdoZXRoZXIgb3Igbm90IHRoZSBwZXJtaXNzaW9ucyBleGlzdCBpbiB0aGlzICovXG4gIGhhcyhwZXJtaXNzaW9uczogUm9sZVRvZ2dsZUtleXMgfCBSb2xlVG9nZ2xlS2V5c1tdKTogYm9vbGVhbiB7XG4gICAgaWYgKCFBcnJheS5pc0FycmF5KHBlcm1pc3Npb25zKSkgcmV0dXJuIHN1cGVyLmNvbnRhaW5zKFJvbGVUb2dnbGVbcGVybWlzc2lvbnNdKVxuXG4gICAgcmV0dXJuIHN1cGVyLmNvbnRhaW5zKHBlcm1pc3Npb25zLnJlZHVjZSgoYSwgYikgPT4gKGEgfD0gUm9sZVRvZ2dsZVtiXSksIDApKVxuICB9XG5cbiAgLyoqIExpc3RzIGFsbCB0aGUgdG9nZ2xlcyBmb3IgdGhlIHJvbGUgYW5kIHdoZXRoZXIgb3Igbm90IGVhY2ggaXMgdHJ1ZSBvciBmYWxzZS4gKi9cbiAgbGlzdCgpOiBSZWNvcmQ8Um9sZVRvZ2dsZUtleXMsIGJvb2xlYW4+IHtcbiAgICBjb25zdCBqc29uOiBSZWNvcmQ8c3RyaW5nLCBib29sZWFuPiA9IHt9XG4gICAgZm9yIChjb25zdCBba2V5LCB2YWx1ZV0gb2YgT2JqZWN0LmVudHJpZXMoUm9sZVRvZ2dsZSkpIHtcbiAgICAgIGpzb25ba2V5XSA9IHN1cGVyLmNvbnRhaW5zKHZhbHVlKVxuICAgIH1cblxuICAgIHJldHVybiBqc29uIGFzIFJlY29yZDxSb2xlVG9nZ2xlS2V5cywgYm9vbGVhbj5cbiAgfVxufVxuXG5leHBvcnQgdHlwZSBSb2xlVG9nZ2xlS2V5cyA9IGtleW9mIHR5cGVvZiBSb2xlVG9nZ2xlXG4iXSwibmFtZXMiOlsiVG9nZ2xlQml0ZmllbGQiLCJSb2xlVG9nZ2xlIiwiaG9pc3QiLCJtYW5hZ2VkIiwibWVudGlvbmFibGUiLCJwcmVtaXVtU3Vic2NyaWJlciIsImF2YWlsYWJsZUZvclB1cmNoYXNlIiwiZ3VpbGRDb25uZWN0aW9ucyIsIlJvbGVUb2dnbGVzIiwiY29uc3RydWN0b3IiLCJyb2xlT3JUb2dnbGVzSW50IiwiYml0ZmllbGQiLCJyb2xlIiwiYWRkIiwidGFncyIsInByZW1pdW1fc3Vic2NyaWJlciIsImF2YWlsYWJsZV9mb3JfcHVyY2hhc2UiLCJndWlsZF9jb25uZWN0aW9ucyIsImhhcyIsInBlcm1pc3Npb25zIiwiQXJyYXkiLCJpc0FycmF5IiwiY29udGFpbnMiLCJyZWR1Y2UiLCJhIiwiYiIsImxpc3QiLCJqc29uIiwia2V5IiwidmFsdWUiLCJPYmplY3QiLCJlbnRyaWVzIl0sIm1hcHBpbmdzIjoiQUFDQSxTQUFTQSxjQUFjLFFBQVEsc0JBQXFCO0FBRXBELE9BQU8sTUFBTUMsYUFBYTtJQUN4QiwwREFBMEQsR0FDMURDLE9BQU8sS0FBSztJQUNaLG1EQUFtRCxHQUNuREMsU0FBUyxLQUFLO0lBQ2QscUNBQXFDLEdBQ3JDQyxhQUFhLEtBQUs7SUFDbEIsdURBQXVELEdBQ3ZEQyxtQkFBbUIsS0FBSztJQUN4QixpREFBaUQsR0FDakRDLHNCQUFzQixLQUFLO0lBQzNCLDBEQUEwRCxHQUMxREMsa0JBQWtCLEtBQUs7QUFDekIsRUFBQztBQUVELE9BQU8sTUFBTUMsb0JBQW9CUjtJQUMvQlMsWUFBWUMsZ0JBQXNDLENBQUU7UUFDbEQsS0FBSztRQUVMLElBQUksT0FBT0EscUJBQXFCLFVBQVUsSUFBSSxDQUFDQyxRQUFRLEdBQUdEO2FBQ3JEO1lBQ0gsTUFBTUUsT0FBT0Y7WUFFYixJQUFJRSxLQUFLVixLQUFLLEVBQUUsSUFBSSxDQUFDVyxHQUFHLENBQUNaLFdBQVdDLEtBQUs7WUFDekMsSUFBSVUsS0FBS1QsT0FBTyxFQUFFLElBQUksQ0FBQ1UsR0FBRyxDQUFDWixXQUFXRSxPQUFPO1lBQzdDLElBQUlTLEtBQUtSLFdBQVcsRUFBRSxJQUFJLENBQUNTLEdBQUcsQ0FBQ1osV0FBV0csV0FBVztZQUNyRCxJQUFJUSxLQUFLRSxJQUFJLEVBQUVDLHVCQUF1QixNQUFNLElBQUksQ0FBQ0YsR0FBRyxDQUFDWixXQUFXSSxpQkFBaUI7WUFDakYsSUFBSU8sS0FBS0UsSUFBSSxFQUFFRSwyQkFBMkIsTUFBTSxJQUFJLENBQUNILEdBQUcsQ0FBQ1osV0FBV0ssb0JBQW9CO1lBQ3hGLElBQUlNLEtBQUtFLElBQUksRUFBRUcsc0JBQXNCLE1BQU0sSUFBSSxDQUFDSixHQUFHLENBQUNaLFdBQVdNLGdCQUFnQjtRQUNqRjtJQUNGO0lBRUEsMERBQTBELEdBQzFELElBQUlMLFFBQWlCO1FBQ25CLE9BQU8sSUFBSSxDQUFDZ0IsR0FBRyxDQUFDO0lBQ2xCO0lBRUEsbURBQW1ELEdBQ25ELElBQUlmLFVBQW1CO1FBQ3JCLE9BQU8sSUFBSSxDQUFDZSxHQUFHLENBQUM7SUFDbEI7SUFFQSxxQ0FBcUMsR0FDckMsSUFBSWQsY0FBdUI7UUFDekIsT0FBTyxJQUFJLENBQUNjLEdBQUcsQ0FBQztJQUNsQjtJQUVBLHVEQUF1RCxHQUN2RCxJQUFJYixvQkFBNkI7UUFDL0IsT0FBTyxJQUFJLENBQUNhLEdBQUcsQ0FBQztJQUNsQjtJQUVBLGlEQUFpRCxHQUNqRCxJQUFJWix1QkFBZ0M7UUFDbEMsT0FBTyxJQUFJLENBQUNZLEdBQUcsQ0FBQztJQUNsQjtJQUVBLDJDQUEyQyxHQUMzQyxJQUFJWCxtQkFBNEI7UUFDOUIsT0FBTyxJQUFJLENBQUNXLEdBQUcsQ0FBQztJQUNsQjtJQUVBLHdEQUF3RCxHQUN4REEsSUFBSUMsV0FBOEMsRUFBVztRQUMzRCxJQUFJLENBQUNDLE1BQU1DLE9BQU8sQ0FBQ0YsY0FBYyxPQUFPLEtBQUssQ0FBQ0csU0FBU3JCLFVBQVUsQ0FBQ2tCLFlBQVk7UUFFOUUsT0FBTyxLQUFLLENBQUNHLFNBQVNILFlBQVlJLE1BQU0sQ0FBQyxDQUFDQyxHQUFHQyxJQUFPRCxLQUFLdkIsVUFBVSxDQUFDd0IsRUFBRSxFQUFHO0lBQzNFO0lBRUEsaUZBQWlGLEdBQ2pGQyxPQUF3QztRQUN0QyxNQUFNQyxPQUFnQyxDQUFDO1FBQ3ZDLEtBQUssTUFBTSxDQUFDQyxLQUFLQyxNQUFNLElBQUlDLE9BQU9DLE9BQU8sQ0FBQzlCLFlBQWE7WUFDckQwQixJQUFJLENBQUNDLElBQUksR0FBRyxLQUFLLENBQUNOLFNBQVNPO1FBQzdCO1FBRUEsT0FBT0Y7SUFDVDtBQUNGIn0=

package/dist/esm/transformers/toggles/user.js

@@ -0,0 +1,45 @@
+import { ToggleBitfield } from './ToggleBitfield.js';
+export const UserToggle = {
+    /** Whether the user belongs to an OAuth2 application */ bot: 1 << 0,
+    /** Whether the user is an Official Discord System user (part of the urgent message system) */ system: 1 << 1,
+    /** Whether the user has two factor enabled on their account */ mfaEnabled: 1 << 2,
+    /** Whether the email on this account has been verified */ verified: 1 << 3
+};
+export class UserToggles extends ToggleBitfield {
+    constructor(userOrTogglesInt){
+        super();
+        if (typeof userOrTogglesInt === 'number') this.bitfield = userOrTogglesInt;
+        else {
+            const user = userOrTogglesInt;
+            if (user.bot) this.add(UserToggle.bot);
+            if (user.system) this.add(UserToggle.system);
+            if (user.mfa_enabled) this.add(UserToggle.mfaEnabled);
+            if (user.verified) this.add(UserToggle.verified);
+        }
+    }
+    /** Whether the user belongs to an OAuth2 application */ get bot() {
+        return this.has('bot');
+    }
+    /** Whether the user is an Official Discord System user (part of the urgent message system) */ get system() {
+        return this.has('system');
+    }
+    /** Whether the user has two factor enabled on their account */ get mfaEnabled() {
+        return this.has('mfaEnabled');
+    }
+    /** Whether the email on this account has been verified */ get verified() {
+        return this.has('verified');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(UserToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= UserToggle[b], 0));
+    }
+    /** Lists all the toggles for the role and whether or not each is true or false. */ list() {
+        const json = {};
+        for (const [key, value] of Object.entries(UserToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transformers/toggles/voice.js

@@ -0,0 +1,60 @@
+import { ToggleBitfield } from './ToggleBitfield.js';
+export const VoiceStateToggle = {
+    /** Whether this user is deafened by the server */ deaf: 1 << 0,
+    /** Whether this user is muted by the server */ mute: 1 << 1,
+    /** Whether this user is locally deafened */ selfDeaf: 1 << 2,
+    /** Whether this user is locally muted */ selfMute: 1 << 3,
+    /** Whether this user is streaming using "Go Live" */ selfStream: 1 << 4,
+    /** Whether this user's camera is enabled */ selfVideo: 1 << 5,
+    /** Whether this user is muted by the current user */ suppress: 1 << 6
+};
+export class VoiceStateToggles extends ToggleBitfield {
+    constructor(voiceOrTogglesInt){
+        super();
+        if (typeof voiceOrTogglesInt === 'number') this.bitfield = voiceOrTogglesInt;
+        else {
+            const voice = voiceOrTogglesInt;
+            if (voice.deaf) this.add(VoiceStateToggle.deaf);
+            if (voice.mute) this.add(VoiceStateToggle.mute);
+            if (voice.self_deaf) this.add(VoiceStateToggle.selfDeaf);
+            if (voice.self_mute) this.add(VoiceStateToggle.selfMute);
+            if (voice.self_stream) this.add(VoiceStateToggle.selfStream);
+            if (voice.self_video) this.add(VoiceStateToggle.selfVideo);
+            if (voice.suppress) this.add(VoiceStateToggle.suppress);
+        }
+    }
+    /** Whether this user is deafened by the server */ get deaf() {
+        return this.has('deaf');
+    }
+    /** Whether this user is muted by the server */ get mute() {
+        return this.has('mute');
+    }
+    /** Whether this user is locally deafened */ get selfDeaf() {
+        return this.has('selfDeaf');
+    }
+    /** Whether this user is locally muted */ get selfMute() {
+        return this.has('selfMute');
+    }
+    /** Whether this user is streaming using "Go Live" */ get selfStream() {
+        return this.has('selfStream');
+    }
+    /** Whether this user's camera is enabled */ get selfVideo() {
+        return this.has('selfVideo');
+    }
+    /** Whether this user is muted by the current user */ get suppress() {
+        return this.has('suppress');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(VoiceStateToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= VoiceStateToggle[b], 0));
+    }
+    /** Lists all the toggles for the role and whether or not each is true or false. */ list() {
+        const json = {};
+        for (const [key, value] of Object.entries(VoiceStateToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transformers/user.js

@@ -0,0 +1,43 @@
+import { iconHashToBigInt } from '@discordeno/utils';
+import { ToggleBitfield, UserToggles } from '../index.js';
+const baseUser = {
+    get tag () {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        return `${this.username}#${this.discriminator}`;
+    },
+    get bot () {
+        return !!this.toggles?.has('bot');
+    },
+    get system () {
+        return !!this.toggles?.has('system');
+    },
+    get mfaEnabled () {
+        return !!this.toggles?.has('mfaEnabled');
+    },
+    get verified () {
+        return !!this.toggles?.has('verified');
+    }
+};
+export function transformUser(bot, payload) {
+    const user = Object.create(baseUser);
+    const props = bot.transformers.desiredProperties.user;
+    if (props.bot || props.system || props.mfaEnabled || props.verified) {
+        user.toggles = new UserToggles(payload);
+    }
+    if (props.flags) user.flags = new ToggleBitfield(payload.flags);
+    if (props.publicFlags) user.publicFlags = new ToggleBitfield(payload.public_flags);
+    if (props.id && payload.id) user.id = bot.transformers.snowflake(payload.id);
+    if (props.username && payload.username) user.username = payload.username;
+    if (props.globalName && payload.global_name) user.globalName = payload.global_name;
+    if (props.discriminator && payload.discriminator) user.discriminator = payload.discriminator;
+    if (props.locale && payload.locale) user.locale = payload.locale;
+    if (props.email && payload.email) user.email = payload.email;
+    if (props.premiumType && payload.premium_type) user.premiumType = payload.premium_type;
+    if (props.avatar && payload.avatar) user.avatar = iconHashToBigInt(payload.avatar);
+    if (props.banner && payload.banner) user.banner = iconHashToBigInt(payload.banner);
+    if (props.accentColor && payload.accent_color) user.accentColor = payload.accent_color;
+    if (props.avatarDecorationData && payload.avatar_decoration_data) user.avatarDecorationData = bot.transformers.avatarDecorationData(bot, payload.avatar_decoration_data);
+    return bot.transformers.customizers.user(bot, payload, user);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/transformers/user.ts"],"sourcesContent":["import type { DiscordUser, PremiumTypes } from '@discordeno/types'\nimport { iconHashToBigInt } from '@discordeno/utils'\nimport { ToggleBitfield, UserToggles, type AvatarDecorationData, type Bot } from '../index.js'\n\nconst baseUser: Partial<User> & BaseUser = {\n  get tag() {\n    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n    return `${this.username}#${this.discriminator}`\n  },\n  get bot() {\n    return !!this.toggles?.has('bot')\n  },\n  get system() {\n    return !!this.toggles?.has('system')\n  },\n  get mfaEnabled() {\n    return !!this.toggles?.has('mfaEnabled')\n  },\n  get verified() {\n    return !!this.toggles?.has('verified')\n  },\n}\n\nexport function transformUser(bot: Bot, payload: DiscordUser): User {\n  const user: User = Object.create(baseUser)\n  const props = bot.transformers.desiredProperties.user\n\n  if (props.bot || props.system || props.mfaEnabled || props.verified) {\n    user.toggles = new UserToggles(payload)\n  }\n  if (props.flags) user.flags = new ToggleBitfield(payload.flags)\n  if (props.publicFlags) user.publicFlags = new ToggleBitfield(payload.public_flags)\n  if (props.id && payload.id) user.id = bot.transformers.snowflake(payload.id)\n  if (props.username && payload.username) user.username = payload.username\n  if (props.globalName && payload.global_name) user.globalName = payload.global_name\n  if (props.discriminator && payload.discriminator) user.discriminator = payload.discriminator\n  if (props.locale && payload.locale) user.locale = payload.locale\n  if (props.email && payload.email) user.email = payload.email\n  if (props.premiumType && payload.premium_type) user.premiumType = payload.premium_type\n  if (props.avatar && payload.avatar) user.avatar = iconHashToBigInt(payload.avatar)\n  if (props.banner && payload.banner) user.banner = iconHashToBigInt(payload.banner)\n  if (props.accentColor && payload.accent_color) user.accentColor = payload.accent_color\n  if (props.avatarDecorationData && payload.avatar_decoration_data)\n    user.avatarDecorationData = bot.transformers.avatarDecorationData(bot, payload.avatar_decoration_data)\n\n  return bot.transformers.customizers.user(bot, payload, user)\n}\n\nexport interface BaseUser {\n  /** The user tag in the form of username#discriminator */\n  tag: string\n  /** Whether the user belongs to an OAuth2 application */\n  bot: boolean\n  /** Whether the user is an Official Discord System user (part of the urgent message system) */\n  system: boolean\n  /** Whether the user has two factor enabled on their account */\n  mfaEnabled: boolean\n  /** Whether the email on this account has been verified */\n  verified: boolean\n}\n\nexport interface User extends BaseUser {\n  /** Compressed version of all the booleans on a user. */\n  toggles?: UserToggles\n  /** The user's username, not unique across the platform */\n  username: string\n  /** The user's display name, if it is set. For bots, this is the application name */\n  globalName?: string\n  /** The user's chosen language option */\n  locale?: string\n  /** The flags on a user's account */\n  flags?: ToggleBitfield\n  /** The type of Nitro subscription on a user's account */\n  premiumType?: PremiumTypes\n  /** The public flags on a user's account */\n  publicFlags?: ToggleBitfield\n  /** the user's banner color encoded as an integer representation of hexadecimal color code */\n  accentColor?: number\n  /** The user's id */\n  id: bigint\n  /** The user's discord-tag */\n  discriminator: string\n  /** The user's avatar hash */\n  avatar?: bigint\n  /** The user's email */\n  email?: string\n  /** the user's banner, or null if unset */\n  banner?: bigint\n  /** data for the user's avatar decoration */\n  avatarDecorationData?: AvatarDecorationData\n}\n"],"names":["iconHashToBigInt","ToggleBitfield","UserToggles","baseUser","tag","username","discriminator","bot","toggles","has","system","mfaEnabled","verified","transformUser","payload","user","Object","create","props","transformers","desiredProperties","flags","publicFlags","public_flags","id","snowflake","globalName","global_name","locale","email","premiumType","premium_type","avatar","banner","accentColor","accent_color","avatarDecorationData","avatar_decoration_data","customizers"],"mappings":"AACA,SAASA,gBAAgB,QAAQ,oBAAmB;AACpD,SAASC,cAAc,EAAEC,WAAW,QAA6C,cAAa;AAE9F,MAAMC,WAAqC;IACzC,IAAIC,OAAM;QACR,4EAA4E;QAC5E,OAAO,CAAC,EAAE,IAAI,CAACC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAACC,aAAa,CAAC,CAAC;IACjD;IACA,IAAIC,OAAM;QACR,OAAO,CAAC,CAAC,IAAI,CAACC,OAAO,EAAEC,IAAI;IAC7B;IACA,IAAIC,UAAS;QACX,OAAO,CAAC,CAAC,IAAI,CAACF,OAAO,EAAEC,IAAI;IAC7B;IACA,IAAIE,cAAa;QACf,OAAO,CAAC,CAAC,IAAI,CAACH,OAAO,EAAEC,IAAI;IAC7B;IACA,IAAIG,YAAW;QACb,OAAO,CAAC,CAAC,IAAI,CAACJ,OAAO,EAAEC,IAAI;IAC7B;AACF;AAEA,OAAO,SAASI,cAAcN,GAAQ,EAAEO,OAAoB;IAC1D,MAAMC,OAAaC,OAAOC,MAAM,CAACd;IACjC,MAAMe,QAAQX,IAAIY,YAAY,CAACC,iBAAiB,CAACL,IAAI;IAErD,IAAIG,MAAMX,GAAG,IAAIW,MAAMR,MAAM,IAAIQ,MAAMP,UAAU,IAAIO,MAAMN,QAAQ,EAAE;QACnEG,KAAKP,OAAO,GAAG,IAAIN,YAAYY;IACjC;IACA,IAAII,MAAMG,KAAK,EAAEN,KAAKM,KAAK,GAAG,IAAIpB,eAAea,QAAQO,KAAK;IAC9D,IAAIH,MAAMI,WAAW,EAAEP,KAAKO,WAAW,GAAG,IAAIrB,eAAea,QAAQS,YAAY;IACjF,IAAIL,MAAMM,EAAE,IAAIV,QAAQU,EAAE,EAAET,KAAKS,EAAE,GAAGjB,IAAIY,YAAY,CAACM,SAAS,CAACX,QAAQU,EAAE;IAC3E,IAAIN,MAAMb,QAAQ,IAAIS,QAAQT,QAAQ,EAAEU,KAAKV,QAAQ,GAAGS,QAAQT,QAAQ;IACxE,IAAIa,MAAMQ,UAAU,IAAIZ,QAAQa,WAAW,EAAEZ,KAAKW,UAAU,GAAGZ,QAAQa,WAAW;IAClF,IAAIT,MAAMZ,aAAa,IAAIQ,QAAQR,aAAa,EAAES,KAAKT,aAAa,GAAGQ,QAAQR,aAAa;IAC5F,IAAIY,MAAMU,MAAM,IAAId,QAAQc,MAAM,EAAEb,KAAKa,MAAM,GAAGd,QAAQc,MAAM;IAChE,IAAIV,MAAMW,KAAK,IAAIf,QAAQe,KAAK,EAAEd,KAAKc,KAAK,GAAGf,QAAQe,KAAK;IAC5D,IAAIX,MAAMY,WAAW,IAAIhB,QAAQiB,YAAY,EAAEhB,KAAKe,WAAW,GAAGhB,QAAQiB,YAAY;IACtF,IAAIb,MAAMc,MAAM,IAAIlB,QAAQkB,MAAM,EAAEjB,KAAKiB,MAAM,GAAGhC,iBAAiBc,QAAQkB,MAAM;IACjF,IAAId,MAAMe,MAAM,IAAInB,QAAQmB,MAAM,EAAElB,KAAKkB,MAAM,GAAGjC,iBAAiBc,QAAQmB,MAAM;IACjF,IAAIf,MAAMgB,WAAW,IAAIpB,QAAQqB,YAAY,EAAEpB,KAAKmB,WAAW,GAAGpB,QAAQqB,YAAY;IACtF,IAAIjB,MAAMkB,oBAAoB,IAAItB,QAAQuB,sBAAsB,EAC9DtB,KAAKqB,oBAAoB,GAAG7B,IAAIY,YAAY,CAACiB,oBAAoB,CAAC7B,KAAKO,QAAQuB,sBAAsB;IAEvG,OAAO9B,IAAIY,YAAY,CAACmB,WAAW,CAACvB,IAAI,CAACR,KAAKO,SAASC;AACzD"}

package/dist/esm/transformers/voiceRegion.js

@@ -0,0 +1,12 @@
+export function transformVoiceRegion(bot, payload) {
+    const voiceRegion = {
+        id: payload.id,
+        name: payload.name,
+        optimal: payload.optimal,
+        deprecated: payload.deprecated,
+        custom: payload.custom
+    };
+    return bot.transformers.customizers.voiceRegion(bot, payload, voiceRegion);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdm9pY2VSZWdpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEaXNjb3JkVm9pY2VSZWdpb24gfSBmcm9tICdAZGlzY29yZGVuby90eXBlcydcbmltcG9ydCB0eXBlIHsgQm90IH0gZnJvbSAnLi4vaW5kZXguanMnXG5cbmV4cG9ydCBmdW5jdGlvbiB0cmFuc2Zvcm1Wb2ljZVJlZ2lvbihib3Q6IEJvdCwgcGF5bG9hZDogRGlzY29yZFZvaWNlUmVnaW9uKTogVm9pY2VSZWdpb24ge1xuICBjb25zdCB2b2ljZVJlZ2lvbiA9IHtcbiAgICBpZDogcGF5bG9hZC5pZCxcbiAgICBuYW1lOiBwYXlsb2FkLm5hbWUsXG4gICAgb3B0aW1hbDogcGF5bG9hZC5vcHRpbWFsLFxuICAgIGRlcHJlY2F0ZWQ6IHBheWxvYWQuZGVwcmVjYXRlZCxcbiAgICBjdXN0b206IHBheWxvYWQuY3VzdG9tLFxuICB9IGFzIFZvaWNlUmVnaW9uXG5cbiAgcmV0dXJuIGJvdC50cmFuc2Zvcm1lcnMuY3VzdG9taXplcnMudm9pY2VSZWdpb24oYm90LCBwYXlsb2FkLCB2b2ljZVJlZ2lvbilcbn1cblxuZXhwb3J0IGludGVyZmFjZSBWb2ljZVJlZ2lvbiB7XG4gIGlkOiBzdHJpbmdcbiAgbmFtZTogc3RyaW5nXG4gIGN1c3RvbTogYm9vbGVhblxuICBvcHRpbWFsOiBib29sZWFuXG4gIGRlcHJlY2F0ZWQ6IGJvb2xlYW5cbn1cbiJdLCJuYW1lcyI6WyJ0cmFuc2Zvcm1Wb2ljZVJlZ2lvbiIsImJvdCIsInBheWxvYWQiLCJ2b2ljZVJlZ2lvbiIsImlkIiwibmFtZSIsIm9wdGltYWwiLCJkZXByZWNhdGVkIiwiY3VzdG9tIiwidHJhbnNmb3JtZXJzIiwiY3VzdG9taXplcnMiXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sU0FBU0EscUJBQXFCQyxHQUFRLEVBQUVDLE9BQTJCO0lBQ3hFLE1BQU1DLGNBQWM7UUFDbEJDLElBQUlGLFFBQVFFLEVBQUU7UUFDZEMsTUFBTUgsUUFBUUcsSUFBSTtRQUNsQkMsU0FBU0osUUFBUUksT0FBTztRQUN4QkMsWUFBWUwsUUFBUUssVUFBVTtRQUM5QkMsUUFBUU4sUUFBUU0sTUFBTTtJQUN4QjtJQUVBLE9BQU9QLElBQUlRLFlBQVksQ0FBQ0MsV0FBVyxDQUFDUCxXQUFXLENBQUNGLEtBQUtDLFNBQVNDO0FBQ2hFIn0=

package/dist/esm/transformers/voiceState.js

@@ -0,0 +1,14 @@
+import { VoiceStateToggles } from './toggles/voice.js';
+export function transformVoiceState(bot, payload) {
+    const props = bot.transformers.desiredProperties.voiceState;
+    const voiceState = {};
+    if (props.requestToSpeakTimestamp && payload.voiceState.request_to_speak_timestamp) voiceState.requestToSpeakTimestamp = Date.parse(payload.voiceState.request_to_speak_timestamp);
+    if (props.channelId && payload.voiceState.channel_id) voiceState.channelId = bot.transformers.snowflake(payload.voiceState.channel_id);
+    if (props.guildId) voiceState.guildId = payload.guildId;
+    if (props.toggles) voiceState.toggles = new VoiceStateToggles(payload.voiceState);
+    if (props.sessionId) voiceState.sessionId = payload.voiceState.session_id;
+    if (props.userId && payload.voiceState.user_id) voiceState.userId = bot.transformers.snowflake(payload.voiceState.user_id) ?? 0n;
+    return bot.transformers.customizers.voiceState(bot, payload.voiceState, voiceState);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdm9pY2VTdGF0ZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERpc2NvcmRWb2ljZVN0YXRlIH0gZnJvbSAnQGRpc2NvcmRlbm8vdHlwZXMnXG5pbXBvcnQgdHlwZSB7IEJvdCB9IGZyb20gJy4uL2luZGV4LmpzJ1xuaW1wb3J0IHsgVm9pY2VTdGF0ZVRvZ2dsZXMgfSBmcm9tICcuL3RvZ2dsZXMvdm9pY2UuanMnXG5cbmV4cG9ydCBmdW5jdGlvbiB0cmFuc2Zvcm1Wb2ljZVN0YXRlKGJvdDogQm90LCBwYXlsb2FkOiB7IHZvaWNlU3RhdGU6IERpc2NvcmRWb2ljZVN0YXRlIH0gJiB7IGd1aWxkSWQ6IGJpZ2ludCB9KTogVm9pY2VTdGF0ZSB7XG4gIGNvbnN0IHByb3BzID0gYm90LnRyYW5zZm9ybWVycy5kZXNpcmVkUHJvcGVydGllcy52b2ljZVN0YXRlXG4gIGNvbnN0IHZvaWNlU3RhdGUgPSB7fSBhcyBWb2ljZVN0YXRlXG5cbiAgaWYgKHByb3BzLnJlcXVlc3RUb1NwZWFrVGltZXN0YW1wICYmIHBheWxvYWQudm9pY2VTdGF0ZS5yZXF1ZXN0X3RvX3NwZWFrX3RpbWVzdGFtcClcbiAgICB2b2ljZVN0YXRlLnJlcXVlc3RUb1NwZWFrVGltZXN0YW1wID0gRGF0ZS5wYXJzZShwYXlsb2FkLnZvaWNlU3RhdGUucmVxdWVzdF90b19zcGVha190aW1lc3RhbXApXG4gIGlmIChwcm9wcy5jaGFubmVsSWQgJiYgcGF5bG9hZC52b2ljZVN0YXRlLmNoYW5uZWxfaWQpIHZvaWNlU3RhdGUuY2hhbm5lbElkID0gYm90LnRyYW5zZm9ybWVycy5zbm93Zmxha2UocGF5bG9hZC52b2ljZVN0YXRlLmNoYW5uZWxfaWQpXG4gIGlmIChwcm9wcy5ndWlsZElkKSB2b2ljZVN0YXRlLmd1aWxkSWQgPSBwYXlsb2FkLmd1aWxkSWRcbiAgaWYgKHByb3BzLnRvZ2dsZXMpIHZvaWNlU3RhdGUudG9nZ2xlcyA9IG5ldyBWb2ljZVN0YXRlVG9nZ2xlcyhwYXlsb2FkLnZvaWNlU3RhdGUpXG4gIGlmIChwcm9wcy5zZXNzaW9uSWQpIHZvaWNlU3RhdGUuc2Vzc2lvbklkID0gcGF5bG9hZC52b2ljZVN0YXRlLnNlc3Npb25faWRcbiAgaWYgKHByb3BzLnVzZXJJZCAmJiBwYXlsb2FkLnZvaWNlU3RhdGUudXNlcl9pZCkgdm9pY2VTdGF0ZS51c2VySWQgPSBib3QudHJhbnNmb3JtZXJzLnNub3dmbGFrZShwYXlsb2FkLnZvaWNlU3RhdGUudXNlcl9pZCkgPz8gMG5cblxuICByZXR1cm4gYm90LnRyYW5zZm9ybWVycy5jdXN0b21pemVycy52b2ljZVN0YXRlKGJvdCwgcGF5bG9hZC52b2ljZVN0YXRlLCB2b2ljZVN0YXRlKVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFZvaWNlU3RhdGUge1xuICByZXF1ZXN0VG9TcGVha1RpbWVzdGFtcD86IG51bWJlclxuICBjaGFubmVsSWQ/OiBiaWdpbnRcbiAgZ3VpbGRJZDogYmlnaW50XG4gIHRvZ2dsZXM6IFZvaWNlU3RhdGVUb2dnbGVzXG4gIHNlc3Npb25JZDogc3RyaW5nXG4gIHVzZXJJZDogYmlnaW50XG59XG4iXSwibmFtZXMiOlsiVm9pY2VTdGF0ZVRvZ2dsZXMiLCJ0cmFuc2Zvcm1Wb2ljZVN0YXRlIiwiYm90IiwicGF5bG9hZCIsInByb3BzIiwidHJhbnNmb3JtZXJzIiwiZGVzaXJlZFByb3BlcnRpZXMiLCJ2b2ljZVN0YXRlIiwicmVxdWVzdFRvU3BlYWtUaW1lc3RhbXAiLCJyZXF1ZXN0X3RvX3NwZWFrX3RpbWVzdGFtcCIsIkRhdGUiLCJwYXJzZSIsImNoYW5uZWxJZCIsImNoYW5uZWxfaWQiLCJzbm93Zmxha2UiLCJndWlsZElkIiwidG9nZ2xlcyIsInNlc3Npb25JZCIsInNlc3Npb25faWQiLCJ1c2VySWQiLCJ1c2VyX2lkIiwiY3VzdG9taXplcnMiXSwibWFwcGluZ3MiOiJBQUVBLFNBQVNBLGlCQUFpQixRQUFRLHFCQUFvQjtBQUV0RCxPQUFPLFNBQVNDLG9CQUFvQkMsR0FBUSxFQUFFQyxPQUFnRTtJQUM1RyxNQUFNQyxRQUFRRixJQUFJRyxZQUFZLENBQUNDLGlCQUFpQixDQUFDQyxVQUFVO0lBQzNELE1BQU1BLGFBQWEsQ0FBQztJQUVwQixJQUFJSCxNQUFNSSx1QkFBdUIsSUFBSUwsUUFBUUksVUFBVSxDQUFDRSwwQkFBMEIsRUFDaEZGLFdBQVdDLHVCQUF1QixHQUFHRSxLQUFLQyxLQUFLLENBQUNSLFFBQVFJLFVBQVUsQ0FBQ0UsMEJBQTBCO0lBQy9GLElBQUlMLE1BQU1RLFNBQVMsSUFBSVQsUUFBUUksVUFBVSxDQUFDTSxVQUFVLEVBQUVOLFdBQVdLLFNBQVMsR0FBR1YsSUFBSUcsWUFBWSxDQUFDUyxTQUFTLENBQUNYLFFBQVFJLFVBQVUsQ0FBQ00sVUFBVTtJQUNySSxJQUFJVCxNQUFNVyxPQUFPLEVBQUVSLFdBQVdRLE9BQU8sR0FBR1osUUFBUVksT0FBTztJQUN2RCxJQUFJWCxNQUFNWSxPQUFPLEVBQUVULFdBQVdTLE9BQU8sR0FBRyxJQUFJaEIsa0JBQWtCRyxRQUFRSSxVQUFVO0lBQ2hGLElBQUlILE1BQU1hLFNBQVMsRUFBRVYsV0FBV1UsU0FBUyxHQUFHZCxRQUFRSSxVQUFVLENBQUNXLFVBQVU7SUFDekUsSUFBSWQsTUFBTWUsTUFBTSxJQUFJaEIsUUFBUUksVUFBVSxDQUFDYSxPQUFPLEVBQUViLFdBQVdZLE1BQU0sR0FBR2pCLElBQUlHLFlBQVksQ0FBQ1MsU0FBUyxDQUFDWCxRQUFRSSxVQUFVLENBQUNhLE9BQU8sS0FBSyxFQUFFO0lBRWhJLE9BQU9sQixJQUFJRyxZQUFZLENBQUNnQixXQUFXLENBQUNkLFVBQVUsQ0FBQ0wsS0FBS0MsUUFBUUksVUFBVSxFQUFFQTtBQUMxRSJ9