@discordeno/bot 21.0.1-next.f6ea699 → 22.0.1-next.269a5bf

package/dist/transformers/toggles/guild.js

@@ -0,0 +1,256 @@
+import { GuildFeatures } from '@discordeno/types';
+import { ToggleBitfieldBigint } from './ToggleBitfield.js';
+const featureNames = [
+    'animatedBanner',
+    'animatedIcon',
+    'applicationCommandPermissionsV2',
+    'autoModeration',
+    'banner',
+    'community',
+    'creatorMonetizableProvisional',
+    'creatorStorePage',
+    'developerSupportServer',
+    'discoverable',
+    'featurable',
+    'invitesDisabled',
+    'inviteSplash',
+    'memberVerificationGateEnabled',
+    'moreSoundboard',
+    'moreStickers',
+    'news',
+    'partnered',
+    'previewEnabled',
+    'raidAlertsDisabled',
+    'roleIcons',
+    'roleSubscriptionsAvailableForPurchase',
+    'roleSubscriptionsEnabled',
+    'ticketedEventsEnabled',
+    'vanityUrl',
+    'verified',
+    'vipRegions',
+    'welcomeScreenEnabled',
+    'guestsEnabled',
+    'guildTags',
+    'enhancedRoleColors'
+];
+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 animated guild banner image */ animatedBanner: 1n << 11n,
+    /** Whether the guild has access to set an animated guild icon */ animatedIcon: 1n << 16n,
+    /** Whether the guild is using the old permissions configuration behavior */ applicationCommandPermissionsV2: 1n << 14n,
+    /** Whether the guild has set up auto moderation rules */ autoModeration: 1n << 28n,
+    /** Whether the guild has access to set a guild banner image */ banner: 1n << 17n,
+    /** 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 been set as a support server on the App Directory */ developerSupportServer: 1n << 30n,
+    /** 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 paused invites, preventing new users from joining */ invitesDisabled: 1n << 29n,
+    /** Whether the guild has access to set an invite splash background */ inviteSplash: 1n << 5n,
+    /** Whether the guild has enabled [Membership Screening](https://discord.com/developers/docs/resources/guild#membership-screening-object) */ memberVerificationGateEnabled: 1n << 19n,
+    /** Whether the guild has more soundboard sound slot */ moreSoundboard: 1n << 24n,
+    /** Whether the guild has increased custom sticker slots */ moreStickers: 1n << 23n,
+    /** Whether the guild has access to create news channels */ news: 1n << 12n,
+    /** Whether the guild is partnered */ partnered: 1n << 9n,
+    /** Whether the guild can be previewed before joining via Membership Screening or the directory */ previewEnabled: 1n << 20n,
+    /** Whether the guild has disabled alerts for join raids in the configured safety alerts channel */ raidAlertsDisabled: 1n << 22n,
+    /** 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 created soundboard sounds. */ soundboard: 1n << 25n,
+    /** Whether the guild has enabled ticketed events */ ticketedEventsEnabled: 1n << 21n,
+    /** Whether the guild has access to set a vanity URL */ vanityUrl: 1n << 7n,
+    /** Whether the guild is verified */ verified: 1n << 8n,
+    /** Whether the guild has access to set 384 kbps bitrate in voice (previously VIP voice servers) */ vipRegions: 1n << 6n,
+    /** Whether the guild has enabled the welcome screen */ welcomeScreenEnabled: 1n << 18n,
+    /** Whether the guild has access to guest invites */ guestsEnabled: 1n << 26n,
+    /** Whether the guild has access to set guild tags */ guildTags: 1n << 36n,
+    /** Whether the guild is able to set gradient colors to roles */ enhancedRoleColors: 1n << 35n
+};
+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.AnimatedBanner)) this.add(GuildToggle.animatedBanner);
+            if (guild.features.includes(GuildFeatures.AnimatedIcon)) this.add(GuildToggle.animatedIcon);
+            if (guild.features.includes(GuildFeatures.ApplicationCommandPermissionsV2)) this.add(GuildToggle.applicationCommandPermissionsV2);
+            if (guild.features.includes(GuildFeatures.AutoModeration)) this.add(GuildToggle.autoModeration);
+            if (guild.features.includes(GuildFeatures.Banner)) this.add(GuildToggle.banner);
+            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.Discoverable)) this.add(GuildToggle.discoverable);
+            if (guild.features.includes(GuildFeatures.Featurable)) this.add(GuildToggle.featurable);
+            if (guild.features.includes(GuildFeatures.InvitesDisabled)) this.add(GuildToggle.invitesDisabled);
+            if (guild.features.includes(GuildFeatures.InviteSplash)) this.add(GuildToggle.inviteSplash);
+            if (guild.features.includes(GuildFeatures.MemberVerificationGateEnabled)) this.add(GuildToggle.memberVerificationGateEnabled);
+            if (guild.features.includes(GuildFeatures.MoreSoundboard)) this.add(GuildToggle.moreSoundboard);
+            if (guild.features.includes(GuildFeatures.MoreStickers)) this.add(GuildToggle.moreStickers);
+            if (guild.features.includes(GuildFeatures.News)) this.add(GuildToggle.news);
+            if (guild.features.includes(GuildFeatures.Partnered)) this.add(GuildToggle.partnered);
+            if (guild.features.includes(GuildFeatures.PreviewEnabled)) this.add(GuildToggle.previewEnabled);
+            if (guild.features.includes(GuildFeatures.RaidAlertsDisabled)) this.add(GuildToggle.raidAlertsDisabled);
+            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.Soundboard)) this.add(GuildToggle.soundboard);
+            if (guild.features.includes(GuildFeatures.TicketedEventsEnabled)) this.add(GuildToggle.ticketedEventsEnabled);
+            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.VipRegions)) this.add(GuildToggle.vipRegions);
+            if (guild.features.includes(GuildFeatures.WelcomeScreenEnabled)) this.add(GuildToggle.welcomeScreenEnabled);
+            if (guild.features.includes(GuildFeatures.GuestsEnabled)) this.add(GuildToggle.guestsEnabled);
+            if (guild.features.includes(GuildFeatures.GuildTags)) this.add(GuildToggle.guildTags);
+            if (guild.features.includes(GuildFeatures.EnhancedRoleColors)) this.add(GuildToggle.enhancedRoleColors);
+        }
+    }
+    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 has more soundboard sound slot */ get moreSoundboard() {
+        return this.has('moreSoundboard');
+    }
+    /** 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 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');
+    }
+    /** Whether the guild is using the old permissions configuration behavior */ get applicationCommandPermissionsV2() {
+        return this.has('applicationCommandPermissionsV2');
+    }
+    /** Whether the guild has enabled monetization. */ get creatorMonetizableProvisional() {
+        return this.has('creatorMonetizableProvisional');
+    }
+    /** Whether the guild has enabled the role subscription promo page. */ get creatorStorePage() {
+        return this.has('creatorStorePage');
+    }
+    /** Whether the guild has disabled alerts for join raids in the configured safety alerts channel */ get raidAlertsDisabled() {
+        return this.has('raidAlertsDisabled');
+    }
+    /** Whether the guild has role subscriptions that can be purchased. */ get roleSubscriptionsAvailableForPurchase() {
+        return this.has('roleSubscriptionsAvailableForPurchase');
+    }
+    /** Whether the guild has enabled role subscriptions. */ get roleSubscriptionsEnabled() {
+        return this.has('roleSubscriptionsEnabled');
+    }
+    /** Whether the guild has created soundboard sounds. */ get soundboard() {
+        return this.has('soundboard');
+    }
+    /** Whether the guild has access to guest invites */ get guestsEnabled() {
+        return this.has('guestsEnabled');
+    }
+    /** Whether the guild has access to set guild tags */ get guildTags() {
+        return this.has('guildTags');
+    }
+    /** Whether the guild is able to set gradient colors to roles */ get enhancedRoleColors() {
+        return this.has('enhancedRoleColors');
+    }
+    /** 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 { type DiscordGuild, GuildFeatures } from '@discordeno/types'\nimport { ToggleBitfieldBigint } from './ToggleBitfield.js'\n\nconst featureNames = [\n  'animatedBanner',\n  'animatedIcon',\n  'applicationCommandPermissionsV2',\n  'autoModeration',\n  'banner',\n  'community',\n  'creatorMonetizableProvisional',\n  'creatorStorePage',\n  'developerSupportServer',\n  'discoverable',\n  'featurable',\n  'invitesDisabled',\n  'inviteSplash',\n  'memberVerificationGateEnabled',\n  'moreSoundboard',\n  'moreStickers',\n  'news',\n  'partnered',\n  'previewEnabled',\n  'raidAlertsDisabled',\n  'roleIcons',\n  'roleSubscriptionsAvailableForPurchase',\n  'roleSubscriptionsEnabled',\n  'ticketedEventsEnabled',\n  'vanityUrl',\n  'verified',\n  'vipRegions',\n  'welcomeScreenEnabled',\n  'guestsEnabled',\n  'guildTags',\n  'enhancedRoleColors',\n] as const\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 animated guild banner image */\n  animatedBanner: 1n << 11n,\n  /** Whether the guild has access to set an animated guild icon */\n  animatedIcon: 1n << 16n,\n  /** Whether the guild is using the old permissions configuration behavior */\n  applicationCommandPermissionsV2: 1n << 14n,\n  /** Whether the guild has set up auto moderation rules */\n  autoModeration: 1n << 28n,\n  /** Whether the guild has access to set a guild banner image */\n  banner: 1n << 17n,\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 been set as a support server on the App Directory */\n  developerSupportServer: 1n << 30n,\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 paused invites, preventing new users from joining */\n  invitesDisabled: 1n << 29n,\n  /** Whether the guild has access to set an invite splash background */\n  inviteSplash: 1n << 5n,\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 has more soundboard sound slot */\n  moreSoundboard: 1n << 24n,\n  /** Whether the guild has increased custom sticker slots */\n  moreStickers: 1n << 23n,\n  /** Whether the guild has access to create news channels */\n  news: 1n << 12n,\n  /** Whether the guild is partnered */\n  partnered: 1n << 9n,\n  /** Whether the guild can be previewed before joining via Membership Screening or the directory */\n  previewEnabled: 1n << 20n,\n  /** Whether the guild has disabled alerts for join raids in the configured safety alerts channel */\n  raidAlertsDisabled: 1n << 22n,\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 created soundboard sounds. */\n  soundboard: 1n << 25n,\n  /** Whether the guild has enabled ticketed events */\n  ticketedEventsEnabled: 1n << 21n,\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 has access to set 384 kbps bitrate in voice (previously VIP voice servers) */\n  vipRegions: 1n << 6n,\n  /** Whether the guild has enabled the welcome screen */\n  welcomeScreenEnabled: 1n << 18n,\n  /** Whether the guild has access to guest invites */\n  guestsEnabled: 1n << 26n,\n  /** Whether the guild has access to set guild tags */\n  guildTags: 1n << 36n,\n  /** Whether the guild is able to set gradient colors to roles */\n  enhancedRoleColors: 1n << 35n,\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.AnimatedBanner)) this.add(GuildToggle.animatedBanner)\n      if (guild.features.includes(GuildFeatures.AnimatedIcon)) this.add(GuildToggle.animatedIcon)\n      if (guild.features.includes(GuildFeatures.ApplicationCommandPermissionsV2)) this.add(GuildToggle.applicationCommandPermissionsV2)\n      if (guild.features.includes(GuildFeatures.AutoModeration)) this.add(GuildToggle.autoModeration)\n      if (guild.features.includes(GuildFeatures.Banner)) this.add(GuildToggle.banner)\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.Discoverable)) this.add(GuildToggle.discoverable)\n      if (guild.features.includes(GuildFeatures.Featurable)) this.add(GuildToggle.featurable)\n      if (guild.features.includes(GuildFeatures.InvitesDisabled)) this.add(GuildToggle.invitesDisabled)\n      if (guild.features.includes(GuildFeatures.InviteSplash)) this.add(GuildToggle.inviteSplash)\n      if (guild.features.includes(GuildFeatures.MemberVerificationGateEnabled)) this.add(GuildToggle.memberVerificationGateEnabled)\n      if (guild.features.includes(GuildFeatures.MoreSoundboard)) this.add(GuildToggle.moreSoundboard)\n      if (guild.features.includes(GuildFeatures.MoreStickers)) this.add(GuildToggle.moreStickers)\n      if (guild.features.includes(GuildFeatures.News)) this.add(GuildToggle.news)\n      if (guild.features.includes(GuildFeatures.Partnered)) this.add(GuildToggle.partnered)\n      if (guild.features.includes(GuildFeatures.PreviewEnabled)) this.add(GuildToggle.previewEnabled)\n      if (guild.features.includes(GuildFeatures.RaidAlertsDisabled)) this.add(GuildToggle.raidAlertsDisabled)\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.Soundboard)) this.add(GuildToggle.soundboard)\n      if (guild.features.includes(GuildFeatures.TicketedEventsEnabled)) this.add(GuildToggle.ticketedEventsEnabled)\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.VipRegions)) this.add(GuildToggle.vipRegions)\n      if (guild.features.includes(GuildFeatures.WelcomeScreenEnabled)) this.add(GuildToggle.welcomeScreenEnabled)\n      if (guild.features.includes(GuildFeatures.GuestsEnabled)) this.add(GuildToggle.guestsEnabled)\n      if (guild.features.includes(GuildFeatures.GuildTags)) this.add(GuildToggle.guildTags)\n      if (guild.features.includes(GuildFeatures.EnhancedRoleColors)) this.add(GuildToggle.enhancedRoleColors)\n    }\n  }\n\n  get features(): GuildFeatureKeys[] {\n    const features: GuildFeatureKeys[] = []\n    for (const key of Object.keys(GuildToggle)) {\n      if (!featureNames.includes(key as GuildFeatureKeys)) continue\n      if (!super.contains(GuildToggle[key as GuildToggleKeys])) continue\n\n      features.push(key as GuildFeatureKeys)\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 has more soundboard sound slot */\n  get moreSoundboard(): boolean {\n    return this.has('moreSoundboard')\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 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  /** Whether the guild is using the old permissions configuration behavior */\n  get applicationCommandPermissionsV2(): boolean {\n    return this.has('applicationCommandPermissionsV2')\n  }\n\n  /** Whether the guild has enabled monetization. */\n  get creatorMonetizableProvisional(): boolean {\n    return this.has('creatorMonetizableProvisional')\n  }\n\n  /** Whether the guild has enabled the role subscription promo page. */\n  get creatorStorePage(): boolean {\n    return this.has('creatorStorePage')\n  }\n\n  /** Whether the guild has disabled alerts for join raids in the configured safety alerts channel */\n  get raidAlertsDisabled(): boolean {\n    return this.has('raidAlertsDisabled')\n  }\n\n  /** Whether the guild has role subscriptions that can be purchased. */\n  get roleSubscriptionsAvailableForPurchase(): boolean {\n    return this.has('roleSubscriptionsAvailableForPurchase')\n  }\n\n  /** Whether the guild has enabled role subscriptions. */\n  get roleSubscriptionsEnabled(): boolean {\n    return this.has('roleSubscriptionsEnabled')\n  }\n\n  /** Whether the guild has created soundboard sounds. */\n  get soundboard(): boolean {\n    return this.has('soundboard')\n  }\n\n  /** Whether the guild has access to guest invites */\n  get guestsEnabled(): boolean {\n    return this.has('guestsEnabled')\n  }\n\n  /** Whether the guild has access to set guild tags */\n  get guildTags(): boolean {\n    return this.has('guildTags')\n  }\n\n  /** Whether the guild is able to set gradient colors to roles */\n  get enhancedRoleColors(): boolean {\n    return this.has('enhancedRoleColors')\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\nexport type GuildFeatureKeys = (typeof featureNames)[number]\n"],"names":["GuildFeatures","ToggleBitfieldBigint","featureNames","GuildToggle","owner","widgetEnabled","large","unavailable","premiumProgressBarEnabled","animatedBanner","animatedIcon","applicationCommandPermissionsV2","autoModeration","banner","community","creatorMonetizableProvisional","creatorStorePage","developerSupportServer","discoverable","featurable","invitesDisabled","inviteSplash","memberVerificationGateEnabled","moreSoundboard","moreStickers","news","partnered","previewEnabled","raidAlertsDisabled","roleIcons","roleSubscriptionsAvailableForPurchase","roleSubscriptionsEnabled","soundboard","ticketedEventsEnabled","vanityUrl","verified","vipRegions","welcomeScreenEnabled","guestsEnabled","guildTags","enhancedRoleColors","GuildToggles","guildOrTogglesBigint","bitfield","guild","features","add","widget_enabled","premium_progress_bar_enabled","includes","AnimatedBanner","AnimatedIcon","ApplicationCommandPermissionsV2","AutoModeration","Banner","Community","CreatorMonetizableProvisional","CreatorStorePage","DeveloperSupportServer","Discoverable","Featurable","InvitesDisabled","InviteSplash","MemberVerificationGateEnabled","MoreSoundboard","MoreStickers","News","Partnered","PreviewEnabled","RaidAlertsDisabled","RoleIcons","RoleSubscriptionsAvailableForPurchase","RoleSubscriptionsEnabled","Soundboard","TicketedEventsEnabled","VanityUrl","Verified","VipRegions","WelcomeScreenEnabled","GuestsEnabled","GuildTags","EnhancedRoleColors","key","Object","keys","contains","push","has","permissions","Array","isArray","reduce","a","b","list","json","value","entries"],"mappings":"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"}

package/dist/transformers/toggles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/toggles/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,qBAAqB,CAAA;AACnC,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA"}

package/dist/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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdG9nZ2xlcy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYW5uZWwuanMnXG5leHBvcnQgKiBmcm9tICcuL2Vtb2ppLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9ndWlsZC5qcydcbmV4cG9ydCAqIGZyb20gJy4vbWVtYmVyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9QZXJtaXNzaW9ucy5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm9sZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vVG9nZ2xlQml0ZmllbGQuanMnXG5leHBvcnQgKiBmcm9tICcuL3VzZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL3ZvaWNlLmpzJ1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBYztBQUM1QixjQUFjLGFBQVk7QUFDMUIsY0FBYyxhQUFZO0FBQzFCLGNBQWMsY0FBYTtBQUMzQixjQUFjLG1CQUFrQjtBQUNoQyxjQUFjLFlBQVc7QUFDekIsY0FBYyxzQkFBcUI7QUFDbkMsY0FBYyxZQUFXO0FBQ3pCLGNBQWMsYUFBWSJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"member.d.ts","sourceRoot":"","sources":["../../../src/transformers/toggles/member.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAe,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,QAAA,MAAM,WAAW,4FAA6F,CAAA;AAE9G,eAAO,MAAM,YAAY;IACvB,qDAAqD;;IAErD,kDAAkD;;IAElD,wFAAwF;;IAKxF,6CAA6C;;IAE7C,sCAAsC;;IAEtC,4DAA4D;;IAE5D,oCAAoC;;IAEpC,mFAAmF;;IAEnF,yDAAyD;;IAEzD,2DAA2D;;IAE3D,yEAAyE;;IAEzE,kDAAkD;;IAElD,+CAA+C;;CAEhD,CAAA;AAED,qBAAa,aAAc,SAAQ,cAAc;gBACnC,kBAAkB,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM;IA0B/D,IAAI,KAAK,IAAI,MAAM,CAelB;IAED,wDAAwD;IACxD,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,kDAAkD;IAClD,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,wFAAwF;IACxF,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,6CAA6C;IAC7C,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,sCAAsC;IACtC,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED,4DAA4D;IAC5D,IAAI,oBAAoB,IAAI,OAAO,CAElC;IAED,oCAAoC;IACpC,IAAI,mBAAmB,IAAI,OAAO,CAEjC;IAED,mFAAmF;IACnF,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,yDAAyD;IACzD,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED,2DAA2D;IAC3D,IAAI,oBAAoB,IAAI,OAAO,CAElC;IAED,yEAAyE;IACzE,IAAI,0BAA0B,IAAI,OAAO,CAExC;IAED,kDAAkD;IAClD,IAAI,4BAA4B,IAAI,OAAO,CAE1C;IAED,+CAA+C;IAC/C,IAAI,0BAA0B,IAAI,OAAO,CAExC;IAED,0DAA0D;IAC1D,GAAG,CAAC,WAAW,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,OAAO;IAMhE,mFAAmF;IACnF,IAAI,IAAI,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC;CAQ1C;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,YAAY,CAAA;AAExD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/transformers/toggles/member.js

@@ -0,0 +1,114 @@
+import { MemberFlags } from '@discordeno/types';
+import { ToggleBitfield } from './ToggleBitfield.js';
+const memberFlags = [
+    'didRejoin',
+    'startedOnboarding',
+    'bypassesVerification',
+    'completedOnboarding'
+];
+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,
+    // Member flags
+    /** Member has left and rejoined the guild */ didRejoin: 1 << 3,
+    /** Member has completed onboarding */ startedOnboarding: 1 << 4,
+    /** Member is exempt from guild verification requirements */ bypassesVerification: 1 << 5,
+    /** Member has started onboarding */ completedOnboarding: 1 << 6,
+    /** Member is a guest and can only access the voice channel they were invited to */ isGuest: 1 << 7,
+    /** Member has started Server Guide new member actions */ startedHomeActions: 1 << 8,
+    /** Member has completed Server Guide new member actions */ completedHomeActions: 1 << 9,
+    /** Member's username, display name, or nickname is blocked by AutoMod */ automodQuarantinedUsername: 1 << 10,
+    /** Member has dismissed the DM settings upsell */ dmSettingsUpsellAcknowledged: 1 << 11,
+    /** Member's guild tag is blocked by AutoMod */ automodQuarantinedGuildTag: 1 << 12
+};
+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);
+            if (member.flags) {
+                if (member.flags & MemberFlags.DidRejoin) this.add(MemberToggle.didRejoin);
+                if (member.flags & MemberFlags.StartedOnboarding) this.add(MemberToggle.startedOnboarding);
+                if (member.flags & MemberFlags.BypassesVerification) this.add(MemberToggle.bypassesVerification);
+                if (member.flags & MemberFlags.CompletedOnboarding) this.add(MemberToggle.completedOnboarding);
+                if (member.flags & MemberFlags.IsGuest) this.add(MemberToggle.isGuest);
+                if (member.flags & MemberFlags.StartedHomeActions) this.add(MemberToggle.startedHomeActions);
+                if (member.flags & MemberFlags.CompletedHomeActions) this.add(MemberToggle.completedHomeActions);
+                if (member.flags & MemberFlags.AutomodQuarantinedUsername) this.add(MemberToggle.automodQuarantinedUsername);
+                if (member.flags & MemberFlags.DmSettingsUpsellAcknowledged) this.add(MemberToggle.dmSettingsUpsellAcknowledged);
+                if (member.flags & MemberFlags.AutomodQuarantinedGuildTag) this.add(MemberToggle.automodQuarantinedGuildTag);
+            }
+        }
+    }
+    get flags() {
+        let flags = 0;
+        if (this.didRejoin) flags |= MemberFlags.DidRejoin;
+        if (this.startedOnboarding) flags |= MemberFlags.StartedOnboarding;
+        if (this.bypassesVerification) flags |= MemberFlags.BypassesVerification;
+        if (this.completedOnboarding) flags |= MemberFlags.CompletedOnboarding;
+        if (this.isGuest) flags |= MemberFlags.IsGuest;
+        if (this.startedHomeActions) flags |= MemberFlags.StartedHomeActions;
+        if (this.completedHomeActions) flags |= MemberFlags.CompletedHomeActions;
+        if (this.automodQuarantinedUsername) flags |= MemberFlags.AutomodQuarantinedUsername;
+        if (this.dmSettingsUpsellAcknowledged) flags |= MemberFlags.DmSettingsUpsellAcknowledged;
+        if (this.automodQuarantinedGuildTag) flags |= MemberFlags.AutomodQuarantinedGuildTag;
+        return flags;
+    }
+    /** 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');
+    }
+    /** Member has left and rejoined the guild */ get didRejoin() {
+        return this.has('didRejoin');
+    }
+    /** Member has completed onboarding */ get startedOnboarding() {
+        return this.has('startedOnboarding');
+    }
+    /** Member is exempt from guild verification requirements */ get bypassesVerification() {
+        return this.has('bypassesVerification');
+    }
+    /** Member has started onboarding */ get completedOnboarding() {
+        return this.has('completedOnboarding');
+    }
+    /** Member is a guest and can only access the voice channel they were invited to */ get isGuest() {
+        return this.has('isGuest');
+    }
+    /** Member has started Server Guide new member actions */ get startedHomeActions() {
+        return this.has('startedHomeActions');
+    }
+    /** Member has completed Server Guide new member actions */ get completedHomeActions() {
+        return this.has('completedHomeActions');
+    }
+    /** Member's username, display name, or nickname is blocked by AutoMod */ get automodQuarantinedUsername() {
+        return this.has('automodQuarantinedUsername');
+    }
+    /** Member has dismissed the DM settings upsell */ get dmSettingsUpsellAcknowledged() {
+        return this.has('dmSettingsUpsellAcknowledged');
+    }
+    /** Member's guild tag is blocked by AutoMod */ get automodQuarantinedGuildTag() {
+        return this.has('automodQuarantinedGuildTag');
+    }
+    /** 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,{"version":3,"sources":["../../../src/transformers/toggles/member.ts"],"sourcesContent":["import { type DiscordMember, MemberFlags } from '@discordeno/types'\nimport { ToggleBitfield } from './ToggleBitfield.js'\n\nconst memberFlags = ['didRejoin', 'startedOnboarding', 'bypassesVerification', 'completedOnboarding'] as const\n\nexport const MemberToggle = {\n  /** Whether the user is deafened in voice channels */\n  deaf: 1 << 0,\n  /** Whether the user is muted in voice channels */\n  mute: 1 << 1,\n  /** Whether the user has not yet passed the guild's Membership Screening requirements */\n  pending: 1 << 2,\n\n  // Member flags\n\n  /** Member has left and rejoined the guild */\n  didRejoin: 1 << 3,\n  /** Member has completed onboarding */\n  startedOnboarding: 1 << 4,\n  /** Member is exempt from guild verification requirements */\n  bypassesVerification: 1 << 5,\n  /** Member has started onboarding */\n  completedOnboarding: 1 << 6,\n  /** Member is a guest and can only access the voice channel they were invited to */\n  isGuest: 1 << 7,\n  /** Member has started Server Guide new member actions */\n  startedHomeActions: 1 << 8,\n  /** Member has completed Server Guide new member actions */\n  completedHomeActions: 1 << 9,\n  /** Member's username, display name, or nickname is blocked by AutoMod */\n  automodQuarantinedUsername: 1 << 10,\n  /** Member has dismissed the DM settings upsell */\n  dmSettingsUpsellAcknowledged: 1 << 11,\n  /** Member's guild tag is blocked by AutoMod */\n  automodQuarantinedGuildTag: 1 << 12,\n}\n\nexport class MemberToggles extends ToggleBitfield {\n  constructor(memberOrTogglesInt: Partial<DiscordMember> | number) {\n    super()\n\n    if (typeof memberOrTogglesInt === 'number') this.bitfield = memberOrTogglesInt\n    else {\n      const member = memberOrTogglesInt\n\n      if (member.deaf) this.add(MemberToggle.deaf)\n      if (member.mute) this.add(MemberToggle.mute)\n      if (member.pending) this.add(MemberToggle.pending)\n\n      if (member.flags) {\n        if (member.flags & MemberFlags.DidRejoin) this.add(MemberToggle.didRejoin)\n        if (member.flags & MemberFlags.StartedOnboarding) this.add(MemberToggle.startedOnboarding)\n        if (member.flags & MemberFlags.BypassesVerification) this.add(MemberToggle.bypassesVerification)\n        if (member.flags & MemberFlags.CompletedOnboarding) this.add(MemberToggle.completedOnboarding)\n        if (member.flags & MemberFlags.IsGuest) this.add(MemberToggle.isGuest)\n        if (member.flags & MemberFlags.StartedHomeActions) this.add(MemberToggle.startedHomeActions)\n        if (member.flags & MemberFlags.CompletedHomeActions) this.add(MemberToggle.completedHomeActions)\n        if (member.flags & MemberFlags.AutomodQuarantinedUsername) this.add(MemberToggle.automodQuarantinedUsername)\n        if (member.flags & MemberFlags.DmSettingsUpsellAcknowledged) this.add(MemberToggle.dmSettingsUpsellAcknowledged)\n        if (member.flags & MemberFlags.AutomodQuarantinedGuildTag) this.add(MemberToggle.automodQuarantinedGuildTag)\n      }\n    }\n  }\n\n  get flags(): number {\n    let flags = 0\n\n    if (this.didRejoin) flags |= MemberFlags.DidRejoin\n    if (this.startedOnboarding) flags |= MemberFlags.StartedOnboarding\n    if (this.bypassesVerification) flags |= MemberFlags.BypassesVerification\n    if (this.completedOnboarding) flags |= MemberFlags.CompletedOnboarding\n    if (this.isGuest) flags |= MemberFlags.IsGuest\n    if (this.startedHomeActions) flags |= MemberFlags.StartedHomeActions\n    if (this.completedHomeActions) flags |= MemberFlags.CompletedHomeActions\n    if (this.automodQuarantinedUsername) flags |= MemberFlags.AutomodQuarantinedUsername\n    if (this.dmSettingsUpsellAcknowledged) flags |= MemberFlags.DmSettingsUpsellAcknowledged\n    if (this.automodQuarantinedGuildTag) flags |= MemberFlags.AutomodQuarantinedGuildTag\n\n    return flags\n  }\n\n  /** Whether the user belongs to an OAuth2 application */\n  get deaf(): boolean {\n    return this.has('deaf')\n  }\n\n  /** Whether the user is muted in voice channels */\n  get mute(): boolean {\n    return this.has('mute')\n  }\n\n  /** Whether the user has not yet passed the guild's Membership Screening requirements */\n  get pending(): boolean {\n    return this.has('pending')\n  }\n\n  /** Member has left and rejoined the guild */\n  get didRejoin(): boolean {\n    return this.has('didRejoin')\n  }\n\n  /** Member has completed onboarding */\n  get startedOnboarding(): boolean {\n    return this.has('startedOnboarding')\n  }\n\n  /** Member is exempt from guild verification requirements */\n  get bypassesVerification(): boolean {\n    return this.has('bypassesVerification')\n  }\n\n  /** Member has started onboarding */\n  get completedOnboarding(): boolean {\n    return this.has('completedOnboarding')\n  }\n\n  /** Member is a guest and can only access the voice channel they were invited to */\n  get isGuest(): boolean {\n    return this.has('isGuest')\n  }\n\n  /** Member has started Server Guide new member actions */\n  get startedHomeActions(): boolean {\n    return this.has('startedHomeActions')\n  }\n\n  /** Member has completed Server Guide new member actions */\n  get completedHomeActions(): boolean {\n    return this.has('completedHomeActions')\n  }\n\n  /** Member's username, display name, or nickname is blocked by AutoMod */\n  get automodQuarantinedUsername(): boolean {\n    return this.has('automodQuarantinedUsername')\n  }\n\n  /** Member has dismissed the DM settings upsell */\n  get dmSettingsUpsellAcknowledged(): boolean {\n    return this.has('dmSettingsUpsellAcknowledged')\n  }\n\n  /** Member's guild tag is blocked by AutoMod */\n  get automodQuarantinedGuildTag(): boolean {\n    return this.has('automodQuarantinedGuildTag')\n  }\n\n  /** Checks whether or not the permissions exist in this */\n  has(permissions: MemberToggleKeys | MemberToggleKeys[]): boolean {\n    if (!Array.isArray(permissions)) return super.contains(MemberToggle[permissions])\n\n    return super.contains(permissions.reduce((a, b) => (a |= MemberToggle[b]), 0))\n  }\n\n  /** Lists all the toggles for the role and whether or not each is true or false. */\n  list(): Record<MemberToggleKeys, boolean> {\n    const json: Record<string, boolean> = {}\n    for (const [key, value] of Object.entries(MemberToggle)) {\n      json[key] = super.contains(value)\n    }\n\n    return json as Record<MemberToggleKeys, boolean>\n  }\n}\n\nexport type MemberToggleKeys = keyof typeof MemberToggle\n\nexport type MemberFlagsKeys = (typeof memberFlags)[number]\n"],"names":["MemberFlags","ToggleBitfield","memberFlags","MemberToggle","deaf","mute","pending","didRejoin","startedOnboarding","bypassesVerification","completedOnboarding","isGuest","startedHomeActions","completedHomeActions","automodQuarantinedUsername","dmSettingsUpsellAcknowledged","automodQuarantinedGuildTag","MemberToggles","memberOrTogglesInt","bitfield","member","add","flags","DidRejoin","StartedOnboarding","BypassesVerification","CompletedOnboarding","IsGuest","StartedHomeActions","CompletedHomeActions","AutomodQuarantinedUsername","DmSettingsUpsellAcknowledged","AutomodQuarantinedGuildTag","has","permissions","Array","isArray","contains","reduce","a","b","list","json","key","value","Object","entries"],"mappings":"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"}

package/dist/transformers/toggles/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../../src/transformers/toggles/role.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,eAAO,MAAM,UAAU;IACrB,4DAA4D;;IAE5D,qDAAqD;;IAErD,uCAAuC;;IAEvC,yDAAyD;;IAEzD,mDAAmD;;IAEnD,4DAA4D;;CAE7D,CAAA;AAED,qBAAa,WAAY,SAAQ,cAAc;gBACjC,gBAAgB,EAAE,WAAW,GAAG,MAAM;IAgBlD,4DAA4D;IAC5D,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,qDAAqD;IACrD,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,uCAAuC;IACvC,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,yDAAyD;IACzD,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED,mDAAmD;IACnD,IAAI,oBAAoB,IAAI,OAAO,CAElC;IAED,6CAA6C;IAC7C,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED,0DAA0D;IAC1D,GAAG,CAAC,WAAW,EAAE,cAAc,GAAG,cAAc,EAAE,GAAG,OAAO;IAM5D,mFAAmF;IACnF,IAAI,IAAI,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC;CAQxC;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,UAAU,CAAA"}

package/dist/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,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

package/dist/transformers/toggles/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/transformers/toggles/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,eAAO,MAAM,UAAU;IACrB,wDAAwD;;IAExD,8FAA8F;;IAE9F,+DAA+D;;IAE/D,0DAA0D;;CAE3D,CAAA;AAED,qBAAa,WAAY,SAAQ,cAAc;gBACjC,gBAAgB,EAAE,WAAW,GAAG,MAAM;IAclD,wDAAwD;IACxD,IAAI,GAAG,IAAI,OAAO,CAEjB;IAED,8FAA8F;IAC9F,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,+DAA+D;IAC/D,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,0DAA0D;IAC1D,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,0DAA0D;IAC1D,GAAG,CAAC,WAAW,EAAE,cAAc,GAAG,cAAc,EAAE,GAAG,OAAO;IAM5D,mFAAmF;IACnF,IAAI,IAAI,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC;CAQxC;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,UAAU,CAAA"}