@jubbio/core 1.0.0

package/dist/utils/IntentsBitField.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Intents BitField for calculating gateway intents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentsBitField = exports.PrivilegedIntents = exports.IntentsAll = exports.GatewayIntentBits = void 0;
+exports.calculateIntents = calculateIntents;
+exports.resolveIntents = resolveIntents;
+const BitField_1 = require("./BitField");
+/**
+ * Gateway Intent Bits
+ */
+exports.GatewayIntentBits = {
+    Guilds: 1 << 0,
+    GuildMembers: 1 << 1,
+    GuildModeration: 1 << 2,
+    GuildEmojisAndStickers: 1 << 3,
+    GuildIntegrations: 1 << 4,
+    GuildWebhooks: 1 << 5,
+    GuildInvites: 1 << 6,
+    GuildVoiceStates: 1 << 7,
+    GuildPresences: 1 << 8,
+    GuildMessages: 1 << 9,
+    GuildMessageReactions: 1 << 10,
+    GuildMessageTyping: 1 << 11,
+    DirectMessages: 1 << 12,
+    DirectMessageReactions: 1 << 13,
+    DirectMessageTyping: 1 << 14,
+    MessageContent: 1 << 15,
+    GuildScheduledEvents: 1 << 16,
+    AutoModerationConfiguration: 1 << 20,
+    AutoModerationExecution: 1 << 21,
+};
+/**
+ * All non-privileged intents
+ */
+exports.IntentsAll = Object.values(exports.GatewayIntentBits).reduce((all, i) => all | i, 0);
+/**
+ * Privileged intents that require approval
+ */
+exports.PrivilegedIntents = exports.GatewayIntentBits.GuildMembers |
+    exports.GatewayIntentBits.GuildPresences |
+    exports.GatewayIntentBits.MessageContent;
+/**
+ * Data structure for gateway intents
+ */
+class IntentsBitField extends BitField_1.BitField {
+    static Flags = exports.GatewayIntentBits;
+    static DefaultBit = 0;
+    constructor(bits = 0) {
+        super(bits);
+    }
+    /**
+     * Check if any privileged intents are enabled
+     */
+    hasPrivileged() {
+        return this.any(exports.PrivilegedIntents);
+    }
+    /**
+     * Get all privileged intents that are enabled
+     */
+    getPrivileged() {
+        const privileged = [];
+        if (this.has(exports.GatewayIntentBits.GuildMembers))
+            privileged.push('GuildMembers');
+        if (this.has(exports.GatewayIntentBits.GuildPresences))
+            privileged.push('GuildPresences');
+        if (this.has(exports.GatewayIntentBits.MessageContent))
+            privileged.push('MessageContent');
+        return privileged;
+    }
+}
+exports.IntentsBitField = IntentsBitField;
+/**
+ * Calculate intents from an array of intent names or values
+ */
+function calculateIntents(intents) {
+    return intents.reduce((acc, intent) => {
+        if (typeof intent === 'number')
+            return acc | intent;
+        if (intent in exports.GatewayIntentBits)
+            return acc | exports.GatewayIntentBits[intent];
+        return acc;
+    }, 0);
+}
+/**
+ * Get all intent names from a bitfield value
+ */
+function resolveIntents(bits) {
+    const names = [];
+    for (const [name, value] of Object.entries(exports.GatewayIntentBits)) {
+        if ((bits & value) === value) {
+            names.push(name);
+        }
+    }
+    return names;
+}
+exports.default = IntentsBitField;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/Partials.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Partials - Handle uncached/partial data structures
+ */
+/**
+ * Partial types that can be enabled
+ */
+export declare enum Partials {
+    User = 0,
+    Channel = 1,
+    GuildMember = 2,
+    Message = 3,
+    Reaction = 4,
+    GuildScheduledEvent = 5,
+    ThreadMember = 6
+}
+/**
+ * Check if a structure is partial (missing data)
+ */
+export declare function isPartial(obj: any): boolean;
+/**
+ * Create a partial user structure
+ */
+export declare function createPartialUser(id: string): PartialUser;
+/**
+ * Create a partial channel structure
+ */
+export declare function createPartialChannel(id: string): PartialChannel;
+/**
+ * Create a partial message structure
+ */
+export declare function createPartialMessage(id: string, channelId: string): PartialMessage;
+/**
+ * Create a partial guild member structure
+ */
+export declare function createPartialGuildMember(userId: string, guildId: string): PartialGuildMember;
+/**
+ * Create a partial reaction structure
+ */
+export declare function createPartialReaction(messageId: string, emoji: string): PartialReaction;
+/**
+ * Partial structure types
+ */
+export interface PartialUser {
+    id: string;
+    partial: true;
+    username: string | null;
+    discriminator: string | null;
+    avatar: string | null;
+    bot: boolean | null;
+    fetch(): Promise<any>;
+    toString(): string;
+}
+export interface PartialChannel {
+    id: string;
+    partial: true;
+    type: number | null;
+    name: string | null;
+    fetch(): Promise<any>;
+    toString(): string;
+}
+export interface PartialMessage {
+    id: string;
+    channelId: string;
+    partial: true;
+    content: string | null;
+    author: any | null;
+    embeds: any[] | null;
+    attachments: any[] | null;
+    fetch(): Promise<any>;
+    toString(): string;
+}
+export interface PartialGuildMember {
+    id: string;
+    guildId: string;
+    partial: true;
+    user: any | null;
+    nick: string | null;
+    roles: string[] | null;
+    joinedAt: Date | null;
+    fetch(): Promise<any>;
+    toString(): string;
+}
+export interface PartialReaction {
+    messageId: string;
+    emoji: string;
+    partial: true;
+    count: number | null;
+    me: boolean | null;
+    fetch(): Promise<any>;
+    toString(): string;
+}
+/**
+ * Make a structure partial-aware with fetch capability
+ */
+export declare function makePartialAware<T extends {
+    id: string;
+}>(structure: T, client: any, fetchFn: (id: string) => Promise<T>): T & {
+    partial: boolean;
+    fetch: () => Promise<T>;
+};
+/**
+ * Check if partials are enabled for a type
+ */
+export declare function hasPartial(client: any, partial: Partials): boolean;
+export default Partials;

package/dist/utils/Partials.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Partials - Handle uncached/partial data structures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Partials = void 0;
+exports.isPartial = isPartial;
+exports.createPartialUser = createPartialUser;
+exports.createPartialChannel = createPartialChannel;
+exports.createPartialMessage = createPartialMessage;
+exports.createPartialGuildMember = createPartialGuildMember;
+exports.createPartialReaction = createPartialReaction;
+exports.makePartialAware = makePartialAware;
+exports.hasPartial = hasPartial;
+/**
+ * Partial types that can be enabled
+ */
+var Partials;
+(function (Partials) {
+    Partials[Partials["User"] = 0] = "User";
+    Partials[Partials["Channel"] = 1] = "Channel";
+    Partials[Partials["GuildMember"] = 2] = "GuildMember";
+    Partials[Partials["Message"] = 3] = "Message";
+    Partials[Partials["Reaction"] = 4] = "Reaction";
+    Partials[Partials["GuildScheduledEvent"] = 5] = "GuildScheduledEvent";
+    Partials[Partials["ThreadMember"] = 6] = "ThreadMember";
+})(Partials || (exports.Partials = Partials = {}));
+/**
+ * Check if a structure is partial (missing data)
+ */
+function isPartial(obj) {
+    return obj?.partial === true;
+}
+/**
+ * Create a partial user structure
+ */
+function createPartialUser(id) {
+    return {
+        id,
+        partial: true,
+        username: null,
+        discriminator: null,
+        avatar: null,
+        bot: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial user without client context');
+        },
+        toString() {
+            return `<@${id}>`;
+        },
+    };
+}
+/**
+ * Create a partial channel structure
+ */
+function createPartialChannel(id) {
+    return {
+        id,
+        partial: true,
+        type: null,
+        name: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial channel without client context');
+        },
+        toString() {
+            return `<#${id}>`;
+        },
+    };
+}
+/**
+ * Create a partial message structure
+ */
+function createPartialMessage(id, channelId) {
+    return {
+        id,
+        channelId,
+        partial: true,
+        content: null,
+        author: null,
+        embeds: null,
+        attachments: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial message without client context');
+        },
+        toString() {
+            return `Message(${id})`;
+        },
+    };
+}
+/**
+ * Create a partial guild member structure
+ */
+function createPartialGuildMember(userId, guildId) {
+    return {
+        id: userId,
+        guildId,
+        partial: true,
+        user: null,
+        nick: null,
+        roles: null,
+        joinedAt: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial member without client context');
+        },
+        toString() {
+            return `<@${userId}>`;
+        },
+    };
+}
+/**
+ * Create a partial reaction structure
+ */
+function createPartialReaction(messageId, emoji) {
+    return {
+        messageId,
+        emoji,
+        partial: true,
+        count: null,
+        me: null,
+        async fetch() {
+            throw new Error('Cannot fetch partial reaction without client context');
+        },
+        toString() {
+            return emoji;
+        },
+    };
+}
+/**
+ * Make a structure partial-aware with fetch capability
+ */
+function makePartialAware(structure, client, fetchFn) {
+    return {
+        ...structure,
+        partial: false,
+        async fetch() {
+            const fetched = await fetchFn(structure.id);
+            Object.assign(this, fetched, { partial: false });
+            return this;
+        },
+    };
+}
+/**
+ * Check if partials are enabled for a type
+ */
+function hasPartial(client, partial) {
+    return client.options?.partials?.includes(partial) ?? false;
+}
+exports.default = Partials;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Partials.js","sourceRoot":"","sources":["../../src/utils/Partials.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAkBH,8BAEC;AAKD,8CAiBC;AAKD,oDAeC;AAKD,oDAkBC;AAKD,4DAkBC;AAKD,sDAgBC;AA8DD,4CAcC;AAKD,gCAEC;AAlND;;GAEG;AACH,IAAY,QAQX;AARD,WAAY,QAAQ;IAClB,uCAAQ,CAAA;IACR,6CAAW,CAAA;IACX,qDAAe,CAAA;IACf,6CAAW,CAAA;IACX,+CAAY,CAAA;IACZ,qEAAuB,CAAA;IACvB,uDAAgB,CAAA;AAClB,CAAC,EARW,QAAQ,wBAAR,QAAQ,QAQnB;AAED;;GAEG;AACH,SAAgB,SAAS,CAAC,GAAQ;IAChC,OAAO,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB,CAAC,EAAU;IAC1C,OAAO;QACL,EAAE;QACF,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,IAAI;QACd,aAAa,EAAE,IAAI;QACnB,MAAM,EAAE,IAAI;QACZ,GAAG,EAAE,IAAI;QAET,KAAK,CAAC,KAAK;YACT,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QAED,QAAQ;YACN,OAAO,KAAK,EAAE,GAAG,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CAAC,EAAU;IAC7C,OAAO;QACL,EAAE;QACF,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QAEV,KAAK,CAAC,KAAK;YACT,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,QAAQ;YACN,OAAO,KAAK,EAAE,GAAG,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CAAC,EAAU,EAAE,SAAiB;IAChE,OAAO;QACL,EAAE;QACF,SAAS;QACT,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI;QACb,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,IAAI;QACZ,WAAW,EAAE,IAAI;QAEjB,KAAK,CAAC,KAAK;YACT,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,QAAQ;YACN,OAAO,WAAW,EAAE,GAAG,CAAC;QAC1B,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,wBAAwB,CAAC,MAAc,EAAE,OAAe;IACtE,OAAO;QACL,EAAE,EAAE,MAAM;QACV,OAAO;QACP,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,IAAI;QACX,QAAQ,EAAE,IAAI;QAEd,KAAK,CAAC,KAAK;YACT,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,QAAQ;YACN,OAAO,KAAK,MAAM,GAAG,CAAC;QACxB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,qBAAqB,CAAC,SAAiB,EAAE,KAAa;IACpE,OAAO;QACL,SAAS;QACT,KAAK;QACL,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,IAAI;QACX,EAAE,EAAE,IAAI;QAER,KAAK,CAAC,KAAK;YACT,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;QAED,QAAQ;YACN,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC;AA2DD;;GAEG;AACH,SAAgB,gBAAgB,CAC9B,SAAY,EACZ,MAAW,EACX,OAAmC;IAEnC,OAAO;QACL,GAAG,SAAS;QACZ,OAAO,EAAE,KAAK;QACd,KAAK,CAAC,KAAK;YACT,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;YACjD,OAAO,IAAS,CAAC;QACnB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,MAAW,EAAE,OAAiB;IACvD,OAAO,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;AAC9D,CAAC;AAED,kBAAe,QAAQ,CAAC","sourcesContent":["/**\r\n * Partials - Handle uncached/partial data structures\r\n */\r\n\r\n/**\r\n * Partial types that can be enabled\r\n */\r\nexport enum Partials {\r\n  User = 0,\r\n  Channel = 1,\r\n  GuildMember = 2,\r\n  Message = 3,\r\n  Reaction = 4,\r\n  GuildScheduledEvent = 5,\r\n  ThreadMember = 6,\r\n}\r\n\r\n/**\r\n * Check if a structure is partial (missing data)\r\n */\r\nexport function isPartial(obj: any): boolean {\r\n  return obj?.partial === true;\r\n}\r\n\r\n/**\r\n * Create a partial user structure\r\n */\r\nexport function createPartialUser(id: string): PartialUser {\r\n  return {\r\n    id,\r\n    partial: true,\r\n    username: null,\r\n    discriminator: null,\r\n    avatar: null,\r\n    bot: null,\r\n    \r\n    async fetch() {\r\n      throw new Error('Cannot fetch partial user without client context');\r\n    },\r\n    \r\n    toString() {\r\n      return `<@${id}>`;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Create a partial channel structure\r\n */\r\nexport function createPartialChannel(id: string): PartialChannel {\r\n  return {\r\n    id,\r\n    partial: true,\r\n    type: null,\r\n    name: null,\r\n    \r\n    async fetch() {\r\n      throw new Error('Cannot fetch partial channel without client context');\r\n    },\r\n    \r\n    toString() {\r\n      return `<#${id}>`;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Create a partial message structure\r\n */\r\nexport function createPartialMessage(id: string, channelId: string): PartialMessage {\r\n  return {\r\n    id,\r\n    channelId,\r\n    partial: true,\r\n    content: null,\r\n    author: null,\r\n    embeds: null,\r\n    attachments: null,\r\n    \r\n    async fetch() {\r\n      throw new Error('Cannot fetch partial message without client context');\r\n    },\r\n    \r\n    toString() {\r\n      return `Message(${id})`;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Create a partial guild member structure\r\n */\r\nexport function createPartialGuildMember(userId: string, guildId: string): PartialGuildMember {\r\n  return {\r\n    id: userId,\r\n    guildId,\r\n    partial: true,\r\n    user: null,\r\n    nick: null,\r\n    roles: null,\r\n    joinedAt: null,\r\n    \r\n    async fetch() {\r\n      throw new Error('Cannot fetch partial member without client context');\r\n    },\r\n    \r\n    toString() {\r\n      return `<@${userId}>`;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Create a partial reaction structure\r\n */\r\nexport function createPartialReaction(messageId: string, emoji: string): PartialReaction {\r\n  return {\r\n    messageId,\r\n    emoji,\r\n    partial: true,\r\n    count: null,\r\n    me: null,\r\n    \r\n    async fetch() {\r\n      throw new Error('Cannot fetch partial reaction without client context');\r\n    },\r\n    \r\n    toString() {\r\n      return emoji;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Partial structure types\r\n */\r\nexport interface PartialUser {\r\n  id: string;\r\n  partial: true;\r\n  username: string | null;\r\n  discriminator: string | null;\r\n  avatar: string | null;\r\n  bot: boolean | null;\r\n  fetch(): Promise<any>;\r\n  toString(): string;\r\n}\r\n\r\nexport interface PartialChannel {\r\n  id: string;\r\n  partial: true;\r\n  type: number | null;\r\n  name: string | null;\r\n  fetch(): Promise<any>;\r\n  toString(): string;\r\n}\r\n\r\nexport interface PartialMessage {\r\n  id: string;\r\n  channelId: string;\r\n  partial: true;\r\n  content: string | null;\r\n  author: any | null;\r\n  embeds: any[] | null;\r\n  attachments: any[] | null;\r\n  fetch(): Promise<any>;\r\n  toString(): string;\r\n}\r\n\r\nexport interface PartialGuildMember {\r\n  id: string;\r\n  guildId: string;\r\n  partial: true;\r\n  user: any | null;\r\n  nick: string | null;\r\n  roles: string[] | null;\r\n  joinedAt: Date | null;\r\n  fetch(): Promise<any>;\r\n  toString(): string;\r\n}\r\n\r\nexport interface PartialReaction {\r\n  messageId: string;\r\n  emoji: string;\r\n  partial: true;\r\n  count: number | null;\r\n  me: boolean | null;\r\n  fetch(): Promise<any>;\r\n  toString(): string;\r\n}\r\n\r\n/**\r\n * Make a structure partial-aware with fetch capability\r\n */\r\nexport function makePartialAware<T extends { id: string }>(\r\n  structure: T,\r\n  client: any,\r\n  fetchFn: (id: string) => Promise<T>\r\n): T & { partial: boolean; fetch: () => Promise<T> } {\r\n  return {\r\n    ...structure,\r\n    partial: false,\r\n    async fetch() {\r\n      const fetched = await fetchFn(structure.id);\r\n      Object.assign(this, fetched, { partial: false });\r\n      return this as T;\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Check if partials are enabled for a type\r\n */\r\nexport function hasPartial(client: any, partial: Partials): boolean {\r\n  return client.options?.partials?.includes(partial) ?? false;\r\n}\r\n\r\nexport default Partials;\r\n"]}

package/dist/utils/PermissionsBitField.d.ts

@@ -0,0 +1,118 @@
+import { PermissionFlagsBits } from '../enums';
+/**
+ * Permission names type
+ */
+export type PermissionString = keyof typeof PermissionFlagsBits;
+/**
+ * Resolvable permission type
+ */
+export type PermissionResolvable = bigint | bigint[] | PermissionString | PermissionString[] | PermissionsBitField;
+/**
+ * Bit field for permissions
+ * API compatible with Discord.js PermissionsBitField
+ */
+export declare class PermissionsBitField {
+    /** The raw bits */
+    bitfield: bigint;
+    /** All permission flags */
+    static Flags: {
+        readonly CreateInstantInvite: bigint;
+        readonly KickMembers: bigint;
+        readonly BanMembers: bigint;
+        readonly Administrator: bigint;
+        readonly ManageChannels: bigint;
+        readonly ManageGuild: bigint;
+        readonly AddReactions: bigint;
+        readonly ViewAuditLog: bigint;
+        readonly ViewGuildInsights: bigint;
+        readonly Stream: bigint;
+        readonly ViewChannel: bigint;
+        readonly SendMessages: bigint;
+        readonly SendTTSMessages: bigint;
+        readonly ManageMessages: bigint;
+        readonly EmbedLinks: bigint;
+        readonly AttachFiles: bigint;
+        readonly ReadMessageHistory: bigint;
+        readonly UseExternalEmojis: bigint;
+        readonly UseSlashCommands: bigint;
+        readonly MentionEveryone: bigint;
+        readonly Connect: bigint;
+        readonly Speak: bigint;
+        readonly MuteMembers: bigint;
+        readonly DeafenMembers: bigint;
+        readonly MoveMembers: bigint;
+        readonly UseVAD: bigint;
+        readonly ChangeCodec: bigint;
+        readonly AudioQualityAdmin: bigint;
+        readonly VideoCall: bigint;
+        readonly ShareScreen: bigint;
+        readonly ShareCamera: bigint;
+        readonly ControlQuality: bigint;
+        readonly RequestToSpeak: bigint;
+        readonly ManageEvents: bigint;
+        readonly AddMembers: bigint;
+        readonly RemoveMembers: bigint;
+        readonly ChangeGroupIcon: bigint;
+        readonly ChangeDMSettings: bigint;
+        readonly ManageGroup: bigint;
+        readonly UseActivities: bigint;
+        readonly ModerateMembers: bigint;
+        readonly ManageRoles: bigint;
+        readonly ManageEmojis: bigint;
+        readonly PrioritySpeaker: bigint;
+    };
+    /** All permissions combined */
+    static All: bigint;
+    /** Default permissions */
+    static Default: bigint;
+    constructor(bits?: PermissionResolvable);
+    /**
+     * Check if this bitfield has a permission
+     */
+    has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    /**
+     * Check if this bitfield has any of the permissions
+     */
+    any(permissions: PermissionResolvable, checkAdmin?: boolean): boolean;
+    /**
+     * Check if this bitfield is missing any permissions
+     */
+    missing(permissions: PermissionResolvable, checkAdmin?: boolean): PermissionString[];
+    /**
+     * Add permissions to this bitfield
+     */
+    add(...permissions: PermissionResolvable[]): this;
+    /**
+     * Remove permissions from this bitfield
+     */
+    remove(...permissions: PermissionResolvable[]): this;
+    /**
+     * Serialize this bitfield to an array of permission names
+     */
+    toArray(): PermissionString[];
+    /**
+     * Serialize this bitfield to a JSON-compatible value
+     */
+    toJSON(): string;
+    /**
+     * Get the string representation
+     */
+    toString(): string;
+    /**
+     * Freeze this bitfield
+     */
+    freeze(): Readonly<this>;
+    /**
+     * Check equality with another bitfield
+     */
+    equals(other: PermissionResolvable): boolean;
+    /**
+     * Create a new bitfield with the same bits
+     */
+    clone(): PermissionsBitField;
+    /**
+     * Resolve a permission to a bigint
+     */
+    static resolve(permission: PermissionResolvable): bigint;
+}
+export default PermissionsBitField;

package/dist/utils/PermissionsBitField.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsBitField = void 0;
+const enums_1 = require("../enums");
+/**
+ * Bit field for permissions
+ * API compatible with Discord.js PermissionsBitField
+ */
+class PermissionsBitField {
+    /** The raw bits */
+    bitfield;
+    /** All permission flags */
+    static Flags = enums_1.PermissionFlagsBits;
+    /** All permissions combined */
+    static All = Object.values(enums_1.PermissionFlagsBits).reduce((acc, val) => acc | val, 0n);
+    /** Default permissions */
+    static Default = BigInt(0);
+    constructor(bits = 0n) {
+        this.bitfield = PermissionsBitField.resolve(bits);
+    }
+    /**
+     * Check if this bitfield has a permission
+     */
+    has(permission, checkAdmin = true) {
+        // Admin has all permissions
+        if (checkAdmin && this.bitfield & enums_1.PermissionFlagsBits.Administrator) {
+            return true;
+        }
+        const bit = PermissionsBitField.resolve(permission);
+        return (this.bitfield & bit) === bit;
+    }
+    /**
+     * Check if this bitfield has any of the permissions
+     */
+    any(permissions, checkAdmin = true) {
+        // Admin has all permissions
+        if (checkAdmin && this.bitfield & enums_1.PermissionFlagsBits.Administrator) {
+            return true;
+        }
+        const bit = PermissionsBitField.resolve(permissions);
+        return (this.bitfield & bit) !== 0n;
+    }
+    /**
+     * Check if this bitfield is missing any permissions
+     */
+    missing(permissions, checkAdmin = true) {
+        const missing = [];
+        for (const [name, bit] of Object.entries(enums_1.PermissionFlagsBits)) {
+            const resolved = PermissionsBitField.resolve(permissions);
+            if ((resolved & bit) && !this.has(bit, checkAdmin)) {
+                missing.push(name);
+            }
+        }
+        return missing;
+    }
+    /**
+     * Add permissions to this bitfield
+     */
+    add(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield |= PermissionsBitField.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Remove permissions from this bitfield
+     */
+    remove(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield &= ~PermissionsBitField.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Serialize this bitfield to an array of permission names
+     */
+    toArray() {
+        const result = [];
+        for (const [name, bit] of Object.entries(enums_1.PermissionFlagsBits)) {
+            if (this.bitfield & bit) {
+                result.push(name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Serialize this bitfield to a JSON-compatible value
+     */
+    toJSON() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Get the string representation
+     */
+    toString() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Freeze this bitfield
+     */
+    freeze() {
+        return Object.freeze(this);
+    }
+    /**
+     * Check equality with another bitfield
+     */
+    equals(other) {
+        return this.bitfield === PermissionsBitField.resolve(other);
+    }
+    /**
+     * Create a new bitfield with the same bits
+     */
+    clone() {
+        return new PermissionsBitField(this.bitfield);
+    }
+    /**
+     * Resolve a permission to a bigint
+     */
+    static resolve(permission) {
+        if (typeof permission === 'bigint') {
+            return permission;
+        }
+        if (permission instanceof PermissionsBitField) {
+            return permission.bitfield;
+        }
+        if (typeof permission === 'string') {
+            const bit = enums_1.PermissionFlagsBits[permission];
+            if (bit === undefined) {
+                throw new Error(`Unknown permission: ${permission}`);
+            }
+            return bit;
+        }
+        if (Array.isArray(permission)) {
+            let result = 0n;
+            for (const p of permission) {
+                result |= PermissionsBitField.resolve(p);
+            }
+            return result;
+        }
+        throw new Error(`Invalid permission: ${permission}`);
+    }
+}
+exports.PermissionsBitField = PermissionsBitField;
+exports.default = PermissionsBitField;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PermissionsBitField.js","sourceRoot":"","sources":["../../src/utils/PermissionsBitField.ts"],"names":[],"mappings":"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","sourcesContent":["import { PermissionFlagsBits } from '../enums';\r\n\r\n/**\r\n * Permission names type\r\n */\r\nexport type PermissionString = keyof typeof PermissionFlagsBits;\r\n\r\n/**\r\n * Resolvable permission type\r\n */\r\nexport type PermissionResolvable = \r\n  | bigint \r\n  | bigint[] \r\n  | PermissionString \r\n  | PermissionString[] \r\n  | PermissionsBitField;\r\n\r\n/**\r\n * Bit field for permissions\r\n * API compatible with Discord.js PermissionsBitField\r\n */\r\nexport class PermissionsBitField {\r\n  /** The raw bits */\r\n  public bitfield: bigint;\r\n\r\n  /** All permission flags */\r\n  static Flags = PermissionFlagsBits;\r\n\r\n  /** All permissions combined */\r\n  static All = Object.values(PermissionFlagsBits).reduce((acc, val) => acc | val, 0n);\r\n\r\n  /** Default permissions */\r\n  static Default = BigInt(0);\r\n\r\n  constructor(bits: PermissionResolvable = 0n) {\r\n    this.bitfield = PermissionsBitField.resolve(bits);\r\n  }\r\n\r\n  /**\r\n   * Check if this bitfield has a permission\r\n   */\r\n  has(permission: PermissionResolvable, checkAdmin = true): boolean {\r\n    // Admin has all permissions\r\n    if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {\r\n      return true;\r\n    }\r\n\r\n    const bit = PermissionsBitField.resolve(permission);\r\n    return (this.bitfield & bit) === bit;\r\n  }\r\n\r\n  /**\r\n   * Check if this bitfield has any of the permissions\r\n   */\r\n  any(permissions: PermissionResolvable, checkAdmin = true): boolean {\r\n    // Admin has all permissions\r\n    if (checkAdmin && this.bitfield & PermissionFlagsBits.Administrator) {\r\n      return true;\r\n    }\r\n\r\n    const bit = PermissionsBitField.resolve(permissions);\r\n    return (this.bitfield & bit) !== 0n;\r\n  }\r\n\r\n  /**\r\n   * Check if this bitfield is missing any permissions\r\n   */\r\n  missing(permissions: PermissionResolvable, checkAdmin = true): PermissionString[] {\r\n    const missing: PermissionString[] = [];\r\n    \r\n    for (const [name, bit] of Object.entries(PermissionFlagsBits)) {\r\n      const resolved = PermissionsBitField.resolve(permissions);\r\n      if ((resolved & bit) && !this.has(bit, checkAdmin)) {\r\n        missing.push(name as PermissionString);\r\n      }\r\n    }\r\n    \r\n    return missing;\r\n  }\r\n\r\n  /**\r\n   * Add permissions to this bitfield\r\n   */\r\n  add(...permissions: PermissionResolvable[]): this {\r\n    for (const permission of permissions) {\r\n      this.bitfield |= PermissionsBitField.resolve(permission);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Remove permissions from this bitfield\r\n   */\r\n  remove(...permissions: PermissionResolvable[]): this {\r\n    for (const permission of permissions) {\r\n      this.bitfield &= ~PermissionsBitField.resolve(permission);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Serialize this bitfield to an array of permission names\r\n   */\r\n  toArray(): PermissionString[] {\r\n    const result: PermissionString[] = [];\r\n    \r\n    for (const [name, bit] of Object.entries(PermissionFlagsBits)) {\r\n      if (this.bitfield & bit) {\r\n        result.push(name as PermissionString);\r\n      }\r\n    }\r\n    \r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Serialize this bitfield to a JSON-compatible value\r\n   */\r\n  toJSON(): string {\r\n    return this.bitfield.toString();\r\n  }\r\n\r\n  /**\r\n   * Get the string representation\r\n   */\r\n  toString(): string {\r\n    return this.bitfield.toString();\r\n  }\r\n\r\n  /**\r\n   * Freeze this bitfield\r\n   */\r\n  freeze(): Readonly<this> {\r\n    return Object.freeze(this);\r\n  }\r\n\r\n  /**\r\n   * Check equality with another bitfield\r\n   */\r\n  equals(other: PermissionResolvable): boolean {\r\n    return this.bitfield === PermissionsBitField.resolve(other);\r\n  }\r\n\r\n  /**\r\n   * Create a new bitfield with the same bits\r\n   */\r\n  clone(): PermissionsBitField {\r\n    return new PermissionsBitField(this.bitfield);\r\n  }\r\n\r\n  /**\r\n   * Resolve a permission to a bigint\r\n   */\r\n  static resolve(permission: PermissionResolvable): bigint {\r\n    if (typeof permission === 'bigint') {\r\n      return permission;\r\n    }\r\n\r\n    if (permission instanceof PermissionsBitField) {\r\n      return permission.bitfield;\r\n    }\r\n\r\n    if (typeof permission === 'string') {\r\n      const bit = PermissionFlagsBits[permission as PermissionString];\r\n      if (bit === undefined) {\r\n        throw new Error(`Unknown permission: ${permission}`);\r\n      }\r\n      return bit;\r\n    }\r\n\r\n    if (Array.isArray(permission)) {\r\n      let result = 0n;\r\n      for (const p of permission) {\r\n        result |= PermissionsBitField.resolve(p);\r\n      }\r\n      return result;\r\n    }\r\n\r\n    throw new Error(`Invalid permission: ${permission}`);\r\n  }\r\n}\r\n\r\nexport default PermissionsBitField;\r\n"]}