@jubbio/core 1.3.1 → 1.3.3

package/dist/cjs/structures/Guild.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guild = void 0;
+const Collection_1 = require("./Collection");
+const GuildMember_1 = require("./GuildMember");
+/**
+ * Represents a guild
+ */
+class Guild {
+    /** Reference to the client */
+    client;
+    /** Guild ID */
+    id;
+    /** Guild name */
+    name;
+    /** Guild icon URL */
+    icon;
+    /** Owner ID */
+    ownerId;
+    /** Whether the guild is unavailable */
+    unavailable;
+    /** Cached members */
+    members;
+    /** Cached channels */
+    channels;
+    constructor(client, data) {
+        this.client = client;
+        this.id = data.id;
+        this.name = data.name;
+        this.icon = data.icon;
+        this.ownerId = data.owner_id;
+        this.unavailable = data.unavailable ?? false;
+        this.members = new Collection_1.Collection();
+        this.channels = new Collection_1.Collection();
+    }
+    /**
+     * Get the guild icon URL
+     */
+    iconURL(options) {
+        if (!this.icon)
+            return null;
+        return this.icon;
+    }
+    /**
+     * Get the voice adapter creator for @jubbio/voice
+     */
+    get voiceAdapterCreator() {
+        return this.client.voice.adapters.get(this.id);
+    }
+    /**
+     * Fetch a member by ID
+     */
+    async fetchMember(userId) {
+        // Check cache first
+        const cached = this.members.get(userId);
+        if (cached)
+            return cached;
+        // Fetch from API
+        const data = await this.client.rest.getMember(this.id, userId);
+        if (!data)
+            throw new Error(`Member ${userId} not found in guild ${this.id}`);
+        const member = this._addMember(data);
+        return member;
+    }
+    /**
+     * Convert to string
+     */
+    toString() {
+        return this.name;
+    }
+    /**
+     * Update guild data
+     */
+    _patch(data) {
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.icon !== undefined)
+            this.icon = data.icon;
+        if (data.owner_id !== undefined)
+            this.ownerId = data.owner_id;
+        if (data.unavailable !== undefined)
+            this.unavailable = data.unavailable;
+    }
+    /**
+     * Add a member to cache
+     */
+    _addMember(data) {
+        const member = new GuildMember_1.GuildMember(this.client, this, data);
+        this.members.set(member.id, member);
+        return member;
+    }
+}
+exports.Guild = Guild;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/structures/GuildMember.d.ts

@@ -0,0 +1,174 @@
+import { APIGuildMember } from '../types';
+import { User } from './User';
+import { Guild } from './Guild';
+import type { Client } from '../Client';
+/**
+ * Permission flags - permission bits
+ * Must match community-service/internal/guild/models/permissions.go (truth of source)
+ */
+export declare const PermissionFlags: {
+    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;
+};
+/**
+ * Permissions helper class
+ */
+export declare class Permissions {
+    private bitfield;
+    private isOwner;
+    constructor(bits?: string | bigint | number, isOwner?: boolean);
+    /**
+     * Check if has a permission
+     */
+    has(permission: string | bigint, checkAdmin?: boolean): boolean;
+    /**
+     * Check if has any of the given permissions
+     */
+    any(permissions: (string | bigint)[], checkAdmin?: boolean): boolean;
+    /**
+     * Return array of permission names that are missing
+     */
+    missing(permissions: (string | bigint)[], checkAdmin?: boolean): string[];
+    /**
+     * Add permissions to this bitfield. Chainable.
+     */
+    add(...permissions: (string | bigint)[]): this;
+    /**
+     * Remove permissions from this bitfield. Chainable.
+     */
+    remove(...permissions: (string | bigint)[]): this;
+    /**
+     * Check equality with another Permissions or bigint
+     */
+    equals(other: Permissions | bigint | string | number): boolean;
+    /**
+     * Create a new Permissions with the same bits
+     */
+    clone(): Permissions;
+    /**
+     * Freeze this instance (immutable)
+     */
+    freeze(): Readonly<this>;
+    /**
+     * Get the raw bitfield
+     */
+    get bits(): bigint;
+    /**
+     * Convert to array of permission names
+     */
+    toArray(): string[];
+    /**
+     * Serialize to JSON-compatible string
+     */
+    toJSON(): string;
+    /**
+     * String representation
+     */
+    toString(): string;
+    /**
+     * Resolve a permission name or bigint to bigint
+     */
+    static resolve(permission: string | bigint): bigint;
+}
+/**
+ * Represents a guild member
+ */
+export declare class GuildMember {
+    /** Reference to the client */
+    readonly client: Client;
+    /** Reference to the guild */
+    readonly guild: Guild;
+    /** The user this member represents */
+    readonly user: User;
+    /** Member's nickname */
+    nickname?: string;
+    /** Member's guild avatar */
+    avatar?: string;
+    /** Role IDs */
+    roles: string[];
+    /** Join timestamp */
+    readonly joinedTimestamp: number;
+    /** Voice state */
+    voice: {
+        channelId?: string;
+        selfMute: boolean;
+        selfDeaf: boolean;
+    };
+    /** Member permissions */
+    permissions: Permissions;
+    constructor(client: Client, guild: Guild, data: APIGuildMember);
+    /**
+     * Get the member's ID
+     */
+    get id(): string;
+    /**
+     * Get the display name (nickname or username)
+     */
+    get displayName(): string;
+    /**
+     * Get the join date
+     */
+    get joinedAt(): Date;
+    /**
+     * Check if member is in a voice channel
+     */
+    get inVoiceChannel(): boolean;
+    /**
+     * Get the member's avatar URL
+     */
+    avatarURL(): string | null;
+    /**
+     * Get the display avatar URL (member avatar or user avatar)
+     */
+    displayAvatarURL(): string;
+    /**
+     * Convert to string (mention format)
+     */
+    toString(): string;
+    /**
+     * Update member data
+     */
+    _patch(data: Partial<APIGuildMember>): void;
+}

package/dist/cjs/structures/GuildMember.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMember = exports.Permissions = exports.PermissionFlags = void 0;
+const User_1 = require("./User");
+/**
+ * Permission flags - permission bits
+ * Must match community-service/internal/guild/models/permissions.go (truth of source)
+ */
+exports.PermissionFlags = {
+    // General (0-9)
+    CreateInstantInvite: 1n << 0n,
+    KickMembers: 1n << 1n,
+    BanMembers: 1n << 2n,
+    Administrator: 1n << 3n,
+    ManageChannels: 1n << 4n,
+    ManageGuild: 1n << 5n,
+    AddReactions: 1n << 6n,
+    ViewAuditLog: 1n << 7n,
+    ViewGuildInsights: 1n << 8n,
+    Stream: 1n << 9n,
+    ViewChannel: 1n << 10n,
+    // Messages (11-19)
+    SendMessages: 1n << 11n,
+    SendTTSMessages: 1n << 12n,
+    ManageMessages: 1n << 13n,
+    EmbedLinks: 1n << 14n,
+    AttachFiles: 1n << 15n,
+    ReadMessageHistory: 1n << 16n,
+    UseExternalEmojis: 1n << 17n,
+    UseSlashCommands: 1n << 18n,
+    MentionEveryone: 1n << 19n,
+    // Voice (20-27)
+    Connect: 1n << 20n,
+    Speak: 1n << 21n,
+    MuteMembers: 1n << 22n,
+    DeafenMembers: 1n << 23n,
+    MoveMembers: 1n << 24n,
+    UseVAD: 1n << 25n,
+    ChangeCodec: 1n << 26n,
+    AudioQualityAdmin: 1n << 27n,
+    // Video and Screen Sharing (28-37)
+    VideoCall: 1n << 28n,
+    ShareScreen: 1n << 29n,
+    ShareCamera: 1n << 30n,
+    ControlQuality: 1n << 31n,
+    RequestToSpeak: 1n << 32n,
+    ManageEvents: 1n << 33n,
+    AddMembers: 1n << 34n,
+    RemoveMembers: 1n << 35n,
+    ChangeGroupIcon: 1n << 36n,
+    ChangeDMSettings: 1n << 37n,
+    // Advanced (38-43)
+    ManageGroup: 1n << 38n,
+    UseActivities: 1n << 39n,
+    ModerateMembers: 1n << 40n,
+    ManageRoles: 1n << 41n,
+    ManageEmojis: 1n << 42n,
+    PrioritySpeaker: 1n << 43n,
+};
+/**
+ * Permissions helper class
+ */
+class Permissions {
+    bitfield;
+    isOwner;
+    constructor(bits = 0n, isOwner = false) {
+        if (typeof bits === 'string') {
+            this.bitfield = BigInt(bits);
+        }
+        else {
+            this.bitfield = BigInt(bits);
+        }
+        this.isOwner = isOwner;
+    }
+    /**
+     * Check if has a permission
+     */
+    has(permission, checkAdmin = true) {
+        // Owner has all permissions
+        if (this.isOwner)
+            return true;
+        // Administrator has all permissions
+        if (checkAdmin && (this.bitfield & exports.PermissionFlags.Administrator) === exports.PermissionFlags.Administrator) {
+            return true;
+        }
+        const bit = Permissions.resolve(permission);
+        return (this.bitfield & bit) === bit;
+    }
+    /**
+     * Check if has any of the given permissions
+     */
+    any(permissions, checkAdmin = true) {
+        // Owner has all permissions
+        if (this.isOwner)
+            return true;
+        // Administrator has all permissions
+        if (checkAdmin && (this.bitfield & exports.PermissionFlags.Administrator) === exports.PermissionFlags.Administrator) {
+            return true;
+        }
+        for (const permission of permissions) {
+            const bit = Permissions.resolve(permission);
+            if ((this.bitfield & bit) === bit)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Return array of permission names that are missing
+     */
+    missing(permissions, checkAdmin = true) {
+        const missing = [];
+        for (const permission of permissions) {
+            if (!this.has(permission, checkAdmin)) {
+                if (typeof permission === 'string') {
+                    missing.push(permission);
+                }
+                else {
+                    // Reverse lookup name from bigint
+                    const name = Object.entries(exports.PermissionFlags).find(([, v]) => v === permission)?.[0];
+                    missing.push(name || permission.toString());
+                }
+            }
+        }
+        return missing;
+    }
+    /**
+     * Add permissions to this bitfield. Chainable.
+     */
+    add(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield |= Permissions.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Remove permissions from this bitfield. Chainable.
+     */
+    remove(...permissions) {
+        for (const permission of permissions) {
+            this.bitfield &= ~Permissions.resolve(permission);
+        }
+        return this;
+    }
+    /**
+     * Check equality with another Permissions or bigint
+     */
+    equals(other) {
+        if (other instanceof Permissions) {
+            return this.bitfield === other.bitfield;
+        }
+        return this.bitfield === BigInt(other);
+    }
+    /**
+     * Create a new Permissions with the same bits
+     */
+    clone() {
+        return new Permissions(this.bitfield, this.isOwner);
+    }
+    /**
+     * Freeze this instance (immutable)
+     */
+    freeze() {
+        return Object.freeze(this);
+    }
+    /**
+     * Get the raw bitfield
+     */
+    get bits() {
+        return this.bitfield;
+    }
+    /**
+     * Convert to array of permission names
+     */
+    toArray() {
+        const result = [];
+        for (const [name, bit] of Object.entries(exports.PermissionFlags)) {
+            if ((this.bitfield & bit) === bit) {
+                result.push(name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Serialize to JSON-compatible string
+     */
+    toJSON() {
+        return this.bitfield.toString();
+    }
+    /**
+     * String representation
+     */
+    toString() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Resolve a permission name or bigint to bigint
+     */
+    static resolve(permission) {
+        if (typeof permission === 'bigint')
+            return permission;
+        const bit = exports.PermissionFlags[permission];
+        if (bit === undefined) {
+            throw new Error(`Unknown permission: ${permission}`);
+        }
+        return bit;
+    }
+}
+exports.Permissions = Permissions;
+/**
+ * Represents a guild member
+ */
+class GuildMember {
+    /** Reference to the client */
+    client;
+    /** Reference to the guild */
+    guild;
+    /** The user this member represents */
+    user;
+    /** Member's nickname */
+    nickname;
+    /** Member's guild avatar */
+    avatar;
+    /** Role IDs */
+    roles;
+    /** Join timestamp */
+    joinedTimestamp;
+    /** Voice state */
+    voice;
+    /** Member permissions */
+    permissions;
+    constructor(client, guild, data) {
+        this.client = client;
+        this.guild = guild;
+        this.user = data.user ? new User_1.User(data.user) : new User_1.User({ id: '0', username: 'Unknown' });
+        this.nickname = data.nick;
+        this.avatar = data.avatar;
+        this.roles = data.roles;
+        this.joinedTimestamp = new Date(data.joined_at).getTime();
+        this.voice = {
+            channelId: data.voice?.channel_id,
+            selfMute: data.voice?.self_mute ?? false,
+            selfDeaf: data.voice?.self_deaf ?? false
+        };
+        // Check if user is guild owner
+        const isOwner = guild.ownerId === this.user.id;
+        // Parse permissions from interaction data
+        this.permissions = new Permissions(data.permissions || '0', isOwner);
+    }
+    /**
+     * Get the member's ID
+     */
+    get id() {
+        return this.user.id;
+    }
+    /**
+     * Get the display name (nickname or username)
+     */
+    get displayName() {
+        return this.nickname || this.user.displayName || this.user.username;
+    }
+    /**
+     * Get the join date
+     */
+    get joinedAt() {
+        return new Date(this.joinedTimestamp);
+    }
+    /**
+     * Check if member is in a voice channel
+     */
+    get inVoiceChannel() {
+        return !!this.voice.channelId;
+    }
+    /**
+     * Get the member's avatar URL
+     */
+    avatarURL() {
+        return this.avatar || null;
+    }
+    /**
+     * Get the display avatar URL (member avatar or user avatar)
+     */
+    displayAvatarURL() {
+        return this.avatar || this.user.displayAvatarURL();
+    }
+    /**
+     * Convert to string (mention format)
+     */
+    toString() {
+        return `<@${this.id}>`;
+    }
+    /**
+     * Update member data
+     */
+    _patch(data) {
+        if (data.nick !== undefined)
+            this.nickname = data.nick;
+        if (data.avatar !== undefined)
+            this.avatar = data.avatar;
+        if (data.roles !== undefined)
+            this.roles = data.roles;
+        if (data.voice !== undefined) {
+            this.voice = {
+                channelId: data.voice.channel_id,
+                selfMute: data.voice.self_mute ?? false,
+                selfDeaf: data.voice.self_deaf ?? false
+            };
+        }
+    }
+}
+exports.GuildMember = GuildMember;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GuildMember.js","sourceRoot":"","sources":["../../../src/structures/GuildMember.ts"],"names":[],"mappings":"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","sourcesContent":["import { APIGuildMember } from '../types';\r\nimport { User } from './User';\r\nimport { Guild } from './Guild';\r\nimport type { Client } from '../Client';\r\n\r\n/**\r\n * Permission flags - permission bits\r\n * Must match community-service/internal/guild/models/permissions.go (truth of source)\r\n */\r\nexport const PermissionFlags = {\r\n  // General (0-9)\r\n  CreateInstantInvite: 1n << 0n,\r\n  KickMembers: 1n << 1n,\r\n  BanMembers: 1n << 2n,\r\n  Administrator: 1n << 3n,\r\n  ManageChannels: 1n << 4n,\r\n  ManageGuild: 1n << 5n,\r\n  AddReactions: 1n << 6n,\r\n  ViewAuditLog: 1n << 7n,\r\n  ViewGuildInsights: 1n << 8n,\r\n  Stream: 1n << 9n,\r\n  ViewChannel: 1n << 10n,\r\n\r\n  // Messages (11-19)\r\n  SendMessages: 1n << 11n,\r\n  SendTTSMessages: 1n << 12n,\r\n  ManageMessages: 1n << 13n,\r\n  EmbedLinks: 1n << 14n,\r\n  AttachFiles: 1n << 15n,\r\n  ReadMessageHistory: 1n << 16n,\r\n  UseExternalEmojis: 1n << 17n,\r\n  UseSlashCommands: 1n << 18n,\r\n  MentionEveryone: 1n << 19n,\r\n\r\n  // Voice (20-27)\r\n  Connect: 1n << 20n,\r\n  Speak: 1n << 21n,\r\n  MuteMembers: 1n << 22n,\r\n  DeafenMembers: 1n << 23n,\r\n  MoveMembers: 1n << 24n,\r\n  UseVAD: 1n << 25n,\r\n  ChangeCodec: 1n << 26n,\r\n  AudioQualityAdmin: 1n << 27n,\r\n\r\n  // Video and Screen Sharing (28-37)\r\n  VideoCall: 1n << 28n,\r\n  ShareScreen: 1n << 29n,\r\n  ShareCamera: 1n << 30n,\r\n  ControlQuality: 1n << 31n,\r\n  RequestToSpeak: 1n << 32n,\r\n  ManageEvents: 1n << 33n,\r\n  AddMembers: 1n << 34n,\r\n  RemoveMembers: 1n << 35n,\r\n  ChangeGroupIcon: 1n << 36n,\r\n  ChangeDMSettings: 1n << 37n,\r\n\r\n  // Advanced (38-43)\r\n  ManageGroup: 1n << 38n,\r\n  UseActivities: 1n << 39n,\r\n  ModerateMembers: 1n << 40n,\r\n  ManageRoles: 1n << 41n,\r\n  ManageEmojis: 1n << 42n,\r\n  PrioritySpeaker: 1n << 43n,\r\n} as const;\r\n\r\n/**\r\n * Permissions helper class\r\n */\r\nexport class Permissions {\r\n  private bitfield: bigint;\r\n  private isOwner: boolean;\r\n\r\n  constructor(bits: string | bigint | number = 0n, isOwner = false) {\r\n    if (typeof bits === 'string') {\r\n      this.bitfield = BigInt(bits);\r\n    } else {\r\n      this.bitfield = BigInt(bits);\r\n    }\r\n    this.isOwner = isOwner;\r\n  }\r\n\r\n  /**\r\n   * Check if has a permission\r\n   */\r\n  has(permission: string | bigint, checkAdmin = true): boolean {\r\n    // Owner has all permissions\r\n    if (this.isOwner) return true;\r\n    \r\n    // Administrator has all permissions\r\n    if (checkAdmin && (this.bitfield & PermissionFlags.Administrator) === PermissionFlags.Administrator) {\r\n      return true;\r\n    }\r\n    \r\n    const bit = Permissions.resolve(permission);\r\n    return (this.bitfield & bit) === bit;\r\n  }\r\n\r\n  /**\r\n   * Check if has any of the given permissions\r\n   */\r\n  any(permissions: (string | bigint)[], checkAdmin = true): boolean {\r\n    // Owner has all permissions\r\n    if (this.isOwner) return true;\r\n    \r\n    // Administrator has all permissions\r\n    if (checkAdmin && (this.bitfield & PermissionFlags.Administrator) === PermissionFlags.Administrator) {\r\n      return true;\r\n    }\r\n    \r\n    for (const permission of permissions) {\r\n      const bit = Permissions.resolve(permission);\r\n      if ((this.bitfield & bit) === bit) return true;\r\n    }\r\n    \r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Return array of permission names that are missing\r\n   */\r\n  missing(permissions: (string | bigint)[], checkAdmin = true): string[] {\r\n    const missing: string[] = [];\r\n    for (const permission of permissions) {\r\n      if (!this.has(permission, checkAdmin)) {\r\n        if (typeof permission === 'string') {\r\n          missing.push(permission);\r\n        } else {\r\n          // Reverse lookup name from bigint\r\n          const name = Object.entries(PermissionFlags).find(([, v]) => v === permission)?.[0];\r\n          missing.push(name || permission.toString());\r\n        }\r\n      }\r\n    }\r\n    return missing;\r\n  }\r\n\r\n  /**\r\n   * Add permissions to this bitfield. Chainable.\r\n   */\r\n  add(...permissions: (string | bigint)[]): this {\r\n    for (const permission of permissions) {\r\n      this.bitfield |= Permissions.resolve(permission);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Remove permissions from this bitfield. Chainable.\r\n   */\r\n  remove(...permissions: (string | bigint)[]): this {\r\n    for (const permission of permissions) {\r\n      this.bitfield &= ~Permissions.resolve(permission);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Check equality with another Permissions or bigint\r\n   */\r\n  equals(other: Permissions | bigint | string | number): boolean {\r\n    if (other instanceof Permissions) {\r\n      return this.bitfield === other.bitfield;\r\n    }\r\n    return this.bitfield === BigInt(other);\r\n  }\r\n\r\n  /**\r\n   * Create a new Permissions with the same bits\r\n   */\r\n  clone(): Permissions {\r\n    return new Permissions(this.bitfield, this.isOwner);\r\n  }\r\n\r\n  /**\r\n   * Freeze this instance (immutable)\r\n   */\r\n  freeze(): Readonly<this> {\r\n    return Object.freeze(this);\r\n  }\r\n\r\n  /**\r\n   * Get the raw bitfield\r\n   */\r\n  get bits(): bigint {\r\n    return this.bitfield;\r\n  }\r\n\r\n  /**\r\n   * Convert to array of permission names\r\n   */\r\n  toArray(): string[] {\r\n    const result: string[] = [];\r\n    for (const [name, bit] of Object.entries(PermissionFlags)) {\r\n      if ((this.bitfield & bit) === bit) {\r\n        result.push(name);\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Serialize to JSON-compatible string\r\n   */\r\n  toJSON(): string {\r\n    return this.bitfield.toString();\r\n  }\r\n\r\n  /**\r\n   * String representation\r\n   */\r\n  toString(): string {\r\n    return this.bitfield.toString();\r\n  }\r\n\r\n  /**\r\n   * Resolve a permission name or bigint to bigint\r\n   */\r\n  static resolve(permission: string | bigint): bigint {\r\n    if (typeof permission === 'bigint') return permission;\r\n    const bit = PermissionFlags[permission as keyof typeof PermissionFlags];\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\r\n/**\r\n * Represents a guild member\r\n */\r\nexport class GuildMember {\r\n  /** Reference to the client */\r\n  public readonly client: Client;\r\n  \r\n  /** Reference to the guild */\r\n  public readonly guild: Guild;\r\n  \r\n  /** The user this member represents */\r\n  public readonly user: User;\r\n  \r\n  /** Member's nickname */\r\n  public nickname?: string;\r\n  \r\n  /** Member's guild avatar */\r\n  public avatar?: string;\r\n  \r\n  /** Role IDs */\r\n  public roles: string[];\r\n  \r\n  /** Join timestamp */\r\n  public readonly joinedTimestamp: number;\r\n  \r\n  /** Voice state */\r\n  public voice: {\r\n    channelId?: string;\r\n    selfMute: boolean;\r\n    selfDeaf: boolean;\r\n  };\r\n  \r\n  /** Member permissions */\r\n  public permissions: Permissions;\r\n\r\n  constructor(client: Client, guild: Guild, data: APIGuildMember) {\r\n    this.client = client;\r\n    this.guild = guild;\r\n    this.user = data.user ? new User(data.user) : new User({ id: '0', username: 'Unknown' });\r\n    this.nickname = data.nick;\r\n    this.avatar = data.avatar;\r\n    this.roles = data.roles;\r\n    this.joinedTimestamp = new Date(data.joined_at).getTime();\r\n    this.voice = {\r\n      channelId: data.voice?.channel_id,\r\n      selfMute: data.voice?.self_mute ?? false,\r\n      selfDeaf: data.voice?.self_deaf ?? false\r\n    };\r\n    \r\n    // Check if user is guild owner\r\n    const isOwner = guild.ownerId === this.user.id;\r\n    \r\n    // Parse permissions from interaction data\r\n    this.permissions = new Permissions(data.permissions || '0', isOwner);\r\n  }\r\n\r\n  /**\r\n   * Get the member's ID\r\n   */\r\n  get id(): string {\r\n    return this.user.id;\r\n  }\r\n\r\n  /**\r\n   * Get the display name (nickname or username)\r\n   */\r\n  get displayName(): string {\r\n    return this.nickname || this.user.displayName || this.user.username;\r\n  }\r\n\r\n  /**\r\n   * Get the join date\r\n   */\r\n  get joinedAt(): Date {\r\n    return new Date(this.joinedTimestamp);\r\n  }\r\n\r\n  /**\r\n   * Check if member is in a voice channel\r\n   */\r\n  get inVoiceChannel(): boolean {\r\n    return !!this.voice.channelId;\r\n  }\r\n\r\n  /**\r\n   * Get the member's avatar URL\r\n   */\r\n  avatarURL(): string | null {\r\n    return this.avatar || null;\r\n  }\r\n\r\n  /**\r\n   * Get the display avatar URL (member avatar or user avatar)\r\n   */\r\n  displayAvatarURL(): string {\r\n    return this.avatar || this.user.displayAvatarURL();\r\n  }\r\n\r\n  /**\r\n   * Convert to string (mention format)\r\n   */\r\n  toString(): string {\r\n    return `<@${this.id}>`;\r\n  }\r\n\r\n  /**\r\n   * Update member data\r\n   */\r\n  _patch(data: Partial<APIGuildMember>): void {\r\n    if (data.nick !== undefined) this.nickname = data.nick;\r\n    if (data.avatar !== undefined) this.avatar = data.avatar;\r\n    if (data.roles !== undefined) this.roles = data.roles;\r\n    if (data.voice !== undefined) {\r\n      this.voice = {\r\n        channelId: data.voice.channel_id,\r\n        selfMute: data.voice.self_mute ?? false,\r\n        selfDeaf: data.voice.self_deaf ?? false\r\n      };\r\n    }\r\n  }\r\n}\r\n"]}