@discordeno/bot 19.0.0-next.fe00a6f → 19.0.0-next.ffdef6c

package/dist/cjs/transformers/toggles/Permissions.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Permissions", {
+    enumerable: true,
+    get: function() {
+        return Permissions;
+    }
+});
+const _types = require("@discordeno/types");
+const _ToggleBitfield = require("./ToggleBitfield.cjs");
+let Permissions = class Permissions extends _ToggleBitfield.ToggleBitfieldBigint {
+    constructor(bits){
+        super(BigInt(bits));
+    }
+    has(permission) {
+        return this.contains(_types.BitwisePermissionFlags[permission]);
+    }
+    hasAll(permissions) {
+        return permissions.every((key)=>this.has(key));
+    }
+    missing(permissions) {
+        return permissions.filter((key)=>!this.has(key));
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdG9nZ2xlcy9QZXJtaXNzaW9ucy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCaXR3aXNlUGVybWlzc2lvbkZsYWdzLCB0eXBlIFBlcm1pc3Npb25TdHJpbmdzIH0gZnJvbSAnQGRpc2NvcmRlbm8vdHlwZXMnXG5pbXBvcnQgeyBUb2dnbGVCaXRmaWVsZEJpZ2ludCB9IGZyb20gJy4vVG9nZ2xlQml0ZmllbGQuanMnXG5cbmV4cG9ydCBjbGFzcyBQZXJtaXNzaW9ucyBleHRlbmRzIFRvZ2dsZUJpdGZpZWxkQmlnaW50IHtcbiAgY29uc3RydWN0b3IoYml0czogc3RyaW5nIHwgYmlnaW50KSB7XG4gICAgc3VwZXIoQmlnSW50KGJpdHMpKVxuICB9XG5cbiAgaGFzKHBlcm1pc3Npb246IFBlcm1pc3Npb25TdHJpbmdzKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuY29udGFpbnMoQml0d2lzZVBlcm1pc3Npb25GbGFnc1twZXJtaXNzaW9uXSlcbiAgfVxuXG4gIGhhc0FsbChwZXJtaXNzaW9uczogUGVybWlzc2lvblN0cmluZ3NbXSk6IGJvb2xlYW4ge1xuICAgIHJldHVybiBwZXJtaXNzaW9ucy5ldmVyeSgoa2V5KSA9PiB0aGlzLmhhcyhrZXkpKVxuICB9XG5cbiAgbWlzc2luZyhwZXJtaXNzaW9uczogUGVybWlzc2lvblN0cmluZ3NbXSk6IFBlcm1pc3Npb25TdHJpbmdzW10ge1xuICAgIHJldHVybiBwZXJtaXNzaW9ucy5maWx0ZXIoKGtleSkgPT4gIXRoaXMuaGFzKGtleSkpXG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJQZXJtaXNzaW9ucyIsIlRvZ2dsZUJpdGZpZWxkQmlnaW50IiwiY29uc3RydWN0b3IiLCJiaXRzIiwiQmlnSW50IiwiaGFzIiwicGVybWlzc2lvbiIsImNvbnRhaW5zIiwiQml0d2lzZVBlcm1pc3Npb25GbGFncyIsImhhc0FsbCIsInBlcm1pc3Npb25zIiwiZXZlcnkiLCJrZXkiLCJtaXNzaW5nIiwiZmlsdGVyIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7dUJBSGtEO2dDQUMxQjtBQUU5QixJQUFBLEFBQU1BLGNBQU4sTUFBTUEsb0JBQW9CQyxvQ0FBb0I7SUFDbkRDLFlBQVlDLElBQXFCLENBQUU7UUFDakMsS0FBSyxDQUFDQyxPQUFPRDtJQUNmO0lBRUFFLElBQUlDLFVBQTZCLEVBQVc7UUFDMUMsT0FBTyxJQUFJLENBQUNDLFFBQVEsQ0FBQ0MsNkJBQXNCLENBQUNGLFdBQVc7SUFDekQ7SUFFQUcsT0FBT0MsV0FBZ0MsRUFBVztRQUNoRCxPQUFPQSxZQUFZQyxLQUFLLENBQUMsQ0FBQ0MsTUFBUSxJQUFJLENBQUNQLEdBQUcsQ0FBQ087SUFDN0M7SUFFQUMsUUFBUUgsV0FBZ0MsRUFBdUI7UUFDN0QsT0FBT0EsWUFBWUksTUFBTSxDQUFDLENBQUNGLE1BQVEsQ0FBQyxJQUFJLENBQUNQLEdBQUcsQ0FBQ087SUFDL0M7QUFDRiJ9

package/dist/cjs/transformers/toggles/ToggleBitfield.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToggleBitfield: function() {
+        return ToggleBitfield;
+    },
+    ToggleBitfieldBigint: function() {
+        return ToggleBitfieldBigint;
+    }
+});
+let ToggleBitfield = class ToggleBitfield {
+    constructor(bitfield){
+        this.bitfield = 0;
+        if (bitfield) this.bitfield = bitfield;
+    }
+    /** Tests whether or not this bitfield has the permission requested. */ contains(bits) {
+        return Boolean(this.bitfield & bits);
+    }
+    /** Adds some bits to the bitfield. */ add(bits) {
+        this.bitfield |= bits;
+        return this;
+    }
+    /** Removes some bits from the bitfield. */ remove(bits) {
+        this.bitfield &= ~bits;
+        return this;
+    }
+    toJSON() {
+        return this.bitfield;
+    }
+};
+let ToggleBitfieldBigint = class ToggleBitfieldBigint {
+    constructor(bitfield){
+        this.bitfield = 0n;
+        if (bitfield) this.bitfield = bitfield;
+    }
+    /** Tests whether or not this bitfield has the permission requested. */ contains(bits) {
+        return Boolean(this.bitfield & bits);
+    }
+    /** Adds some bits to the bitfield. */ add(bits) {
+        this.bitfield |= bits;
+        return this;
+    }
+    /** Removes some bits from the bitfield. */ remove(bits) {
+        this.bitfield &= ~bits;
+        return this;
+    }
+    toJSON() {
+        return this.bitfield.toString();
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/transformers/toggles/channel.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ChannelToggle: function() {
+        return ChannelToggle;
+    },
+    ChannelToggles: function() {
+        return ChannelToggles;
+    }
+});
+const _ToggleBitfield = require("./ToggleBitfield.cjs");
+const ChannelToggle = {
+    /** Whether the channel is nsfw */ nsfw: 1 << 0,
+    /** When a thread is locked, only users with `MANAGE_THREADS` can unarchive it */ locked: 1 << 1,
+    /** whether non-moderators can add other non-moderators to a thread; only available on private threads */ invitable: 1 << 2,
+    /** Whether the thread is archived */ archived: 1 << 3,
+    /** When a thread is created this will be true on that channel payload for the thread. */ newlyCreated: 1 << 4,
+    /** for group DM channels: whether the channel is managed by an application via the `gdm.join` OAuth2 scope */ managed: 1 << 5
+};
+let ChannelToggles = class ChannelToggles extends _ToggleBitfield.ToggleBitfield {
+    constructor(channelOrBitfield){
+        super();
+        if (typeof channelOrBitfield === 'number') this.bitfield = channelOrBitfield;
+        else {
+            const channel = channelOrBitfield;
+            if (channel.nsfw) this.add(ChannelToggle.nsfw);
+            if (channel.thread_metadata?.locked) this.add(ChannelToggle.locked);
+            if (channel.thread_metadata?.invitable) this.add(ChannelToggle.invitable);
+            if (channel.thread_metadata?.archived) this.add(ChannelToggle.archived);
+            if (channel.newly_created) this.add(ChannelToggle.newlyCreated);
+            if (channel.managed) this.add(ChannelToggle.managed);
+        }
+    }
+    /** Whether or not this channel is an nsfw channel. */ get nsfw() {
+        return this.has('nsfw');
+    }
+    /** Whether or not this thread channel is locked. */ get locked() {
+        return this.has('locked');
+    }
+    /** Whether or not this thread channel is invitable. */ get invitable() {
+        return this.has('invitable');
+    }
+    /** Whether or not this thread channel is archived. */ get archived() {
+        return this.has('archived');
+    }
+    /** Whether or not this thread channel is newly created. */ get newlyCreated() {
+        return this.has('newlyCreated');
+    }
+    get managed() {
+        return this.has('managed');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(ChannelToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= ChannelToggle[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(ChannelToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/transformers/toggles/emoji.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    EmojiToggle: function() {
+        return EmojiToggle;
+    },
+    EmojiToggles: function() {
+        return EmojiToggles;
+    }
+});
+const _ToggleBitfield = require("./ToggleBitfield.cjs");
+const EmojiToggle = {
+    /** Whether this emoji must be wrapped in colons */ requireColons: 1 << 0,
+    /** Whether this emoji is managed */ managed: 1 << 1,
+    /** Whether this emoji is animated */ animated: 1 << 2,
+    /** Whether this emoji can be used, may be false due to loss of Server Boosts */ available: 1 << 3
+};
+let EmojiToggles = class EmojiToggles extends _ToggleBitfield.ToggleBitfield {
+    constructor(roleOrTogglesInt){
+        super();
+        if (typeof roleOrTogglesInt === 'number') this.bitfield = roleOrTogglesInt;
+        else {
+            const role = roleOrTogglesInt;
+            if (role.require_colons) this.add(EmojiToggle.requireColons);
+            if (role.managed) this.add(EmojiToggle.managed);
+            if (role.animated) this.add(EmojiToggle.animated);
+            if (role.available) this.add(EmojiToggle.available);
+        }
+    }
+    /** Whether this emoji must be wrapped in colons */ get requireColons() {
+        return this.has('requireColons');
+    }
+    /** Whether this emoji is managed */ get managed() {
+        return this.has('managed');
+    }
+    /** Whether this emoji is animated */ get animated() {
+        return this.has('animated');
+    }
+    /** Whether this emoji can be used, may be false due to loss of Server Boosts */ get available() {
+        return this.has('available');
+    }
+    /** Checks whether or not the permissions exist in this */ has(permissions) {
+        if (!Array.isArray(permissions)) return super.contains(EmojiToggle[permissions]);
+        return super.contains(permissions.reduce((a, b)=>a |= EmojiToggle[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(EmojiToggle)){
+            json[key] = super.contains(value);
+        }
+        return json;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/transformers/toggles/guild.cjs

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    GuildToggle: function() {
+        return GuildToggle;
+    },
+    GuildToggles: function() {
+        return GuildToggles;
+    }
+});
+const _types = require("@discordeno/types");
+const _ToggleBitfield = require("./ToggleBitfield.cjs");
+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'
+];
+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
+    // MISSING VALUES IN THE BITFIELD: 26, 35+
+    /** 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
+};
+let GuildToggles = class GuildToggles extends _ToggleBitfield.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(_types.GuildFeatures.AnimatedBanner)) this.add(GuildToggle.animatedBanner);
+            if (guild.features.includes(_types.GuildFeatures.AnimatedIcon)) this.add(GuildToggle.animatedIcon);
+            if (guild.features.includes(_types.GuildFeatures.ApplicationCommandPermissionsV2)) this.add(GuildToggle.applicationCommandPermissionsV2);
+            if (guild.features.includes(_types.GuildFeatures.AutoModeration)) this.add(GuildToggle.autoModeration);
+            if (guild.features.includes(_types.GuildFeatures.Banner)) this.add(GuildToggle.banner);
+            if (guild.features.includes(_types.GuildFeatures.Community)) this.add(GuildToggle.community);
+            if (guild.features.includes(_types.GuildFeatures.CreatorMonetizableProvisional)) this.add(GuildToggle.creatorMonetizableProvisional);
+            if (guild.features.includes(_types.GuildFeatures.CreatorStorePage)) this.add(GuildToggle.creatorStorePage);
+            if (guild.features.includes(_types.GuildFeatures.DeveloperSupportServer)) this.add(GuildToggle.developerSupportServer);
+            if (guild.features.includes(_types.GuildFeatures.Discoverable)) this.add(GuildToggle.discoverable);
+            if (guild.features.includes(_types.GuildFeatures.Featurable)) this.add(GuildToggle.featurable);
+            if (guild.features.includes(_types.GuildFeatures.InvitesDisabled)) this.add(GuildToggle.invitesDisabled);
+            if (guild.features.includes(_types.GuildFeatures.InviteSplash)) this.add(GuildToggle.inviteSplash);
+            if (guild.features.includes(_types.GuildFeatures.MemberVerificationGateEnabled)) this.add(GuildToggle.memberVerificationGateEnabled);
+            if (guild.features.includes(_types.GuildFeatures.MoreSoundboard)) this.add(GuildToggle.moreSoundboard);
+            if (guild.features.includes(_types.GuildFeatures.MoreStickers)) this.add(GuildToggle.moreStickers);
+            if (guild.features.includes(_types.GuildFeatures.News)) this.add(GuildToggle.news);
+            if (guild.features.includes(_types.GuildFeatures.Partnered)) this.add(GuildToggle.partnered);
+            if (guild.features.includes(_types.GuildFeatures.PreviewEnabled)) this.add(GuildToggle.previewEnabled);
+            if (guild.features.includes(_types.GuildFeatures.RaidAlertsDisabled)) this.add(GuildToggle.raidAlertsDisabled);
+            if (guild.features.includes(_types.GuildFeatures.RoleIcons)) this.add(GuildToggle.roleIcons);
+            if (guild.features.includes(_types.GuildFeatures.RoleSubscriptionsAvailableForPurchase)) this.add(GuildToggle.roleSubscriptionsAvailableForPurchase);
+            if (guild.features.includes(_types.GuildFeatures.RoleSubscriptionsEnabled)) this.add(GuildToggle.roleSubscriptionsEnabled);
+            if (guild.features.includes(_types.GuildFeatures.Soundboard)) this.add(GuildToggle.soundboard);
+            if (guild.features.includes(_types.GuildFeatures.TicketedEventsEnabled)) this.add(GuildToggle.ticketedEventsEnabled);
+            if (guild.features.includes(_types.GuildFeatures.VanityUrl)) this.add(GuildToggle.vanityUrl);
+            if (guild.features.includes(_types.GuildFeatures.Verified)) this.add(GuildToggle.verified);
+            if (guild.features.includes(_types.GuildFeatures.VipRegions)) this.add(GuildToggle.vipRegions);
+            if (guild.features.includes(_types.GuildFeatures.WelcomeScreenEnabled)) this.add(GuildToggle.welcomeScreenEnabled);
+        }
+    }
+    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');
+    }
+    /** 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] 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  // MISSING VALUES IN THE BITFIELD: 26, 35+\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}\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    }\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  /** 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":["GuildToggle","GuildToggles","featureNames","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","ToggleBitfieldBigint","constructor","guildOrTogglesBigint","bitfield","guild","features","add","widget_enabled","premium_progress_bar_enabled","includes","GuildFeatures","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","key","Object","keys","contains","push","has","permissions","Array","isArray","reduce","a","b","list","json","value","entries"],"mappings":"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"}

package/dist/cjs/transformers/toggles/index.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./channel.cjs"), exports);
+_export_star(require("./emoji.cjs"), exports);
+_export_star(require("./guild.cjs"), exports);
+_export_star(require("./member.cjs"), exports);
+_export_star(require("./Permissions.cjs"), exports);
+_export_star(require("./role.cjs"), exports);
+_export_star(require("./ToggleBitfield.cjs"), exports);
+_export_star(require("./user.cjs"), exports);
+_export_star(require("./voice.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90cmFuc2Zvcm1lcnMvdG9nZ2xlcy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYW5uZWwuanMnXG5leHBvcnQgKiBmcm9tICcuL2Vtb2ppLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9ndWlsZC5qcydcbmV4cG9ydCAqIGZyb20gJy4vbWVtYmVyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9QZXJtaXNzaW9ucy5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm9sZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vVG9nZ2xlQml0ZmllbGQuanMnXG5leHBvcnQgKiBmcm9tICcuL3VzZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL3ZvaWNlLmpzJ1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWM7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0EifQ==