@jubbio/core 1.0.0

package/dist/managers/GuildMemberManager.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Manager for guild members with caching and lazy loading
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMemberManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const Collection_1 = require("../utils/Collection");
+/**
+ * Manages guild members
+ */
+class GuildMemberManager extends BaseManager_1.CachedManager {
+    /** The guild this manager belongs to */
+    guild;
+    constructor(guild, iterable) {
+        // Use a simple object as placeholder since we don't have GuildMember class yet
+        super(guild.client, Object, iterable);
+        this.guild = guild;
+    }
+    /**
+     * Add a member to the cache
+     */
+    _add(data, cache = true) {
+        const id = data.user?.id ?? data.id;
+        const existing = this.cache.get(id);
+        if (existing) {
+            if (cache) {
+                Object.assign(existing, data);
+            }
+            return existing;
+        }
+        const member = {
+            id,
+            guildId: this.guild.id,
+            user: data.user,
+            nick: data.nick,
+            roles: data.roles ?? [],
+            joinedAt: data.joined_at ? new Date(data.joined_at) : null,
+            premiumSince: data.premium_since ? new Date(data.premium_since) : null,
+            deaf: data.deaf ?? false,
+            mute: data.mute ?? false,
+            pending: data.pending ?? false,
+            permissions: data.permissions,
+            communicationDisabledUntil: data.communication_disabled_until
+                ? new Date(data.communication_disabled_until)
+                : null,
+            // Helper methods
+            get displayName() {
+                return this.nick ?? this.user?.display_name ?? this.user?.username ?? 'Unknown';
+            },
+            toString() {
+                return `<@${this.id}>`;
+            },
+        };
+        if (cache) {
+            this.cache.set(id, member);
+        }
+        return member;
+    }
+    /**
+     * Fetch a member from the API
+     */
+    async fetch(id, options) {
+        if (!options?.force) {
+            const existing = this.cache.get(id);
+            if (existing)
+                return existing;
+        }
+        const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/members/${id}`);
+        return this._add(data, options?.cache ?? true);
+    }
+    /**
+     * Fetch multiple members
+     */
+    async fetchMany(options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.after)
+            params.set('after', options.after);
+        if (options?.query)
+            params.set('query', options.query);
+        const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/members?${params}`);
+        const members = new Collection_1.Collection();
+        for (const memberData of data) {
+            const member = this._add(memberData);
+            members.set(member.id, member);
+        }
+        return members;
+    }
+    /**
+     * Search for members by query
+     */
+    async search(options) {
+        return this.fetchMany({ query: options.query, limit: options.limit ?? 10 });
+    }
+    /**
+     * Kick a member
+     */
+    async kick(id, reason) {
+        await this.client.rest.request('DELETE', `/guilds/${this.guild.id}/members/${id}`, reason ? { reason } : undefined);
+        this.cache.delete(id);
+    }
+    /**
+     * Ban a member
+     */
+    async ban(id, options) {
+        await this.client.rest.request('PUT', `/guilds/${this.guild.id}/bans/${id}`, {
+            delete_message_days: options?.deleteMessageDays,
+            reason: options?.reason,
+        });
+        this.cache.delete(id);
+    }
+    /**
+     * Unban a user
+     */
+    async unban(id, reason) {
+        await this.client.rest.request('DELETE', `/guilds/${this.guild.id}/bans/${id}`, reason ? { reason } : undefined);
+    }
+    /**
+     * Edit a member
+     */
+    async edit(id, data) {
+        const body = {};
+        if (data.nick !== undefined)
+            body.nick = data.nick;
+        if (data.roles !== undefined)
+            body.roles = data.roles;
+        if (data.mute !== undefined)
+            body.mute = data.mute;
+        if (data.deaf !== undefined)
+            body.deaf = data.deaf;
+        if (data.channel_id !== undefined)
+            body.channel_id = data.channel_id;
+        if (data.communication_disabled_until !== undefined) {
+            body.communication_disabled_until = data.communication_disabled_until?.toISOString() ?? null;
+        }
+        const result = await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/members/${id}`, body);
+        return this._add(result);
+    }
+    /**
+     * Add a role to a member
+     */
+    async addRole(memberId, roleId, reason) {
+        await this.client.rest.request('PUT', `/guilds/${this.guild.id}/members/${memberId}/roles/${roleId}`, reason ? { reason } : undefined);
+    }
+    /**
+     * Remove a role from a member
+     */
+    async removeRole(memberId, roleId, reason) {
+        await this.client.rest.request('DELETE', `/guilds/${this.guild.id}/members/${memberId}/roles/${roleId}`, reason ? { reason } : undefined);
+    }
+}
+exports.GuildMemberManager = GuildMemberManager;
+exports.default = GuildMemberManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GuildMemberManager.js","sourceRoot":"","sources":["../../src/managers/GuildMemberManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Manager for guild members with caching and lazy loading\r\n */\r\n\r\nimport { CachedManager } from './BaseManager';\r\nimport { Collection } from '../utils/Collection';\r\n\r\n/**\r\n * Manages guild members\r\n */\r\nexport class GuildMemberManager extends CachedManager<string, any> {\r\n  /** The guild this manager belongs to */\r\n  public readonly guild: any;\r\n\r\n  constructor(guild: any, iterable?: Iterable<any>) {\r\n    // Use a simple object as placeholder since we don't have GuildMember class yet\r\n    super(guild.client, Object as any, iterable);\r\n    this.guild = guild;\r\n  }\r\n\r\n  /**\r\n   * Add a member to the cache\r\n   */\r\n  _add(data: any, cache = true): any {\r\n    const id = data.user?.id ?? data.id;\r\n    const existing = this.cache.get(id);\r\n    \r\n    if (existing) {\r\n      if (cache) {\r\n        Object.assign(existing, data);\r\n      }\r\n      return existing;\r\n    }\r\n    \r\n    const member = {\r\n      id,\r\n      guildId: this.guild.id,\r\n      user: data.user,\r\n      nick: data.nick,\r\n      roles: data.roles ?? [],\r\n      joinedAt: data.joined_at ? new Date(data.joined_at) : null,\r\n      premiumSince: data.premium_since ? new Date(data.premium_since) : null,\r\n      deaf: data.deaf ?? false,\r\n      mute: data.mute ?? false,\r\n      pending: data.pending ?? false,\r\n      permissions: data.permissions,\r\n      communicationDisabledUntil: data.communication_disabled_until \r\n        ? new Date(data.communication_disabled_until) \r\n        : null,\r\n      \r\n      // Helper methods\r\n      get displayName() {\r\n        return this.nick ?? this.user?.display_name ?? this.user?.username ?? 'Unknown';\r\n      },\r\n      \r\n      toString() {\r\n        return `<@${this.id}>`;\r\n      },\r\n    };\r\n    \r\n    if (cache) {\r\n      this.cache.set(id, member);\r\n    }\r\n    \r\n    return member;\r\n  }\r\n\r\n  /**\r\n   * Fetch a member from the API\r\n   */\r\n  async fetch(id: string, options?: { cache?: boolean; force?: boolean }): Promise<any> {\r\n    if (!options?.force) {\r\n      const existing = this.cache.get(id);\r\n      if (existing) return existing;\r\n    }\r\n    \r\n    const data = await this.client.rest.request(\r\n      'GET',\r\n      `/guilds/${this.guild.id}/members/${id}`\r\n    );\r\n    \r\n    return this._add(data, options?.cache ?? true);\r\n  }\r\n\r\n  /**\r\n   * Fetch multiple members\r\n   */\r\n  async fetchMany(options?: { \r\n    limit?: number; \r\n    after?: string;\r\n    query?: string;\r\n  }): Promise<Collection<string, any>> {\r\n    const params = new URLSearchParams();\r\n    if (options?.limit) params.set('limit', String(options.limit));\r\n    if (options?.after) params.set('after', options.after);\r\n    if (options?.query) params.set('query', options.query);\r\n    \r\n    const data = await this.client.rest.request(\r\n      'GET',\r\n      `/guilds/${this.guild.id}/members?${params}`\r\n    );\r\n    \r\n    const members = new Collection<string, any>();\r\n    for (const memberData of data) {\r\n      const member = this._add(memberData);\r\n      members.set(member.id, member);\r\n    }\r\n    \r\n    return members;\r\n  }\r\n\r\n  /**\r\n   * Search for members by query\r\n   */\r\n  async search(options: { query: string; limit?: number }): Promise<Collection<string, any>> {\r\n    return this.fetchMany({ query: options.query, limit: options.limit ?? 10 });\r\n  }\r\n\r\n  /**\r\n   * Kick a member\r\n   */\r\n  async kick(id: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request(\r\n      'DELETE',\r\n      `/guilds/${this.guild.id}/members/${id}`,\r\n      reason ? { reason } : undefined\r\n    );\r\n    this.cache.delete(id);\r\n  }\r\n\r\n  /**\r\n   * Ban a member\r\n   */\r\n  async ban(id: string, options?: { deleteMessageDays?: number; reason?: string }): Promise<void> {\r\n    await this.client.rest.request(\r\n      'PUT',\r\n      `/guilds/${this.guild.id}/bans/${id}`,\r\n      {\r\n        delete_message_days: options?.deleteMessageDays,\r\n        reason: options?.reason,\r\n      }\r\n    );\r\n    this.cache.delete(id);\r\n  }\r\n\r\n  /**\r\n   * Unban a user\r\n   */\r\n  async unban(id: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request(\r\n      'DELETE',\r\n      `/guilds/${this.guild.id}/bans/${id}`,\r\n      reason ? { reason } : undefined\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Edit a member\r\n   */\r\n  async edit(id: string, data: {\r\n    nick?: string | null;\r\n    roles?: string[];\r\n    mute?: boolean;\r\n    deaf?: boolean;\r\n    channel_id?: string | null;\r\n    communication_disabled_until?: Date | null;\r\n  }): Promise<any> {\r\n    const body: any = {};\r\n    if (data.nick !== undefined) body.nick = data.nick;\r\n    if (data.roles !== undefined) body.roles = data.roles;\r\n    if (data.mute !== undefined) body.mute = data.mute;\r\n    if (data.deaf !== undefined) body.deaf = data.deaf;\r\n    if (data.channel_id !== undefined) body.channel_id = data.channel_id;\r\n    if (data.communication_disabled_until !== undefined) {\r\n      body.communication_disabled_until = data.communication_disabled_until?.toISOString() ?? null;\r\n    }\r\n    \r\n    const result = await this.client.rest.request(\r\n      'PATCH',\r\n      `/guilds/${this.guild.id}/members/${id}`,\r\n      body\r\n    );\r\n    \r\n    return this._add(result);\r\n  }\r\n\r\n  /**\r\n   * Add a role to a member\r\n   */\r\n  async addRole(memberId: string, roleId: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request(\r\n      'PUT',\r\n      `/guilds/${this.guild.id}/members/${memberId}/roles/${roleId}`,\r\n      reason ? { reason } : undefined\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Remove a role from a member\r\n   */\r\n  async removeRole(memberId: string, roleId: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request(\r\n      'DELETE',\r\n      `/guilds/${this.guild.id}/members/${memberId}/roles/${roleId}`,\r\n      reason ? { reason } : undefined\r\n    );\r\n  }\r\n}\r\n\r\nexport default GuildMemberManager;\r\n"]}

package/dist/managers/RoleManager.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Manager for roles with caching and lazy loading
+ */
+import { CachedManager } from './BaseManager';
+import { Collection } from '../utils/Collection';
+/**
+ * Manages roles for a guild
+ */
+export declare class RoleManager extends CachedManager<string, any> {
+    /** The guild this manager belongs to */
+    readonly guild: any;
+    constructor(guild: any, iterable?: Iterable<any>);
+    /**
+     * Get the @everyone role
+     */
+    get everyone(): any;
+    /**
+     * Get the highest role
+     */
+    get highest(): any;
+    /**
+     * Get the bot's highest role
+     */
+    get botRoleFor(): (userId: string) => any | null;
+    /**
+     * Add a role to the cache
+     */
+    _add(data: any, cache?: boolean): any;
+    /**
+     * Fetch a role from the API
+     */
+    fetch(id: string, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<any>;
+    /**
+     * Fetch all roles for the guild
+     */
+    fetchAll(): Promise<Collection<string, any>>;
+    /**
+     * Create a new role
+     */
+    create(options?: {
+        name?: string;
+        color?: number | string;
+        hoist?: boolean;
+        position?: number;
+        permissions?: string | bigint;
+        mentionable?: boolean;
+        icon?: string;
+        unicodeEmoji?: string;
+        reason?: string;
+    }): Promise<any>;
+    /**
+     * Delete a role
+     */
+    delete(id: string, reason?: string): Promise<void>;
+    /**
+     * Edit a role
+     */
+    edit(id: string, data: {
+        name?: string;
+        color?: number | string;
+        hoist?: boolean;
+        position?: number;
+        permissions?: string | bigint;
+        mentionable?: boolean;
+        icon?: string | null;
+        unicodeEmoji?: string | null;
+        reason?: string;
+    }): Promise<any>;
+    /**
+     * Set role positions
+     */
+    setPositions(positions: Array<{
+        role: string;
+        position: number;
+    }>): Promise<Collection<string, any>>;
+    /**
+     * Compare two roles by position
+     */
+    comparePositions(role1: string | any, role2: string | any): number;
+}
+export default RoleManager;

package/dist/managers/RoleManager.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Manager for roles with caching and lazy loading
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const Collection_1 = require("../utils/Collection");
+/**
+ * Manages roles for a guild
+ */
+class RoleManager extends BaseManager_1.CachedManager {
+    /** The guild this manager belongs to */
+    guild;
+    constructor(guild, iterable) {
+        super(guild.client, Object, iterable);
+        this.guild = guild;
+    }
+    /**
+     * Get the @everyone role
+     */
+    get everyone() {
+        return this.cache.get(this.guild.id) ?? null;
+    }
+    /**
+     * Get the highest role
+     */
+    get highest() {
+        return this.cache.reduce((prev, role) => (role.position > (prev?.position ?? -1)) ? role : prev, null);
+    }
+    /**
+     * Get the bot's highest role
+     */
+    get botRoleFor() {
+        return (userId) => {
+            const member = this.guild.members?.cache.get(userId);
+            if (!member)
+                return null;
+            return this.cache
+                .filter((role) => member.roles?.includes(role.id))
+                .sort((a, b) => b.position - a.position)
+                .first() ?? null;
+        };
+    }
+    /**
+     * Add a role to the cache
+     */
+    _add(data, cache = true) {
+        const id = data.id;
+        const existing = this.cache.get(id);
+        if (existing) {
+            if (cache)
+                Object.assign(existing, data);
+            return existing;
+        }
+        const role = {
+            id,
+            guildId: this.guild.id,
+            name: data.name,
+            color: data.color ?? 0,
+            hoist: data.hoist ?? false,
+            position: data.position ?? 0,
+            permissions: data.permissions ?? '0',
+            managed: data.managed ?? false,
+            mentionable: data.mentionable ?? false,
+            icon: data.icon ?? null,
+            unicodeEmoji: data.unicode_emoji ?? null,
+            tags: data.tags ?? null,
+            get hexColor() {
+                return `#${this.color.toString(16).padStart(6, '0')}`;
+            },
+            get createdAt() {
+                const timestamp = BigInt(this.id) >> 22n;
+                return new Date(Number(timestamp) + 1640995200000); // Jubbio epoch
+            },
+            toString() {
+                return this.id === this.guildId ? '@everyone' : `<@&${this.id}>`;
+            },
+            comparePositionTo(role) {
+                return this.position - (role?.position ?? 0);
+            },
+            async edit(data) {
+                return this.guild.roles.edit(this.id, data);
+            },
+            async delete(reason) {
+                return this.guild.roles.delete(this.id, reason);
+            },
+            async setPosition(position) {
+                return this.guild.roles.setPositions([{ role: this.id, position }]);
+            },
+        };
+        if (cache)
+            this.cache.set(id, role);
+        return role;
+    }
+    /**
+     * Fetch a role from the API
+     */
+    async fetch(id, options) {
+        if (!options?.force) {
+            const existing = this.cache.get(id);
+            if (existing)
+                return existing;
+        }
+        // Roles are fetched as part of guild, so fetch all
+        const roles = await this.fetchAll();
+        return roles.get(id) ?? null;
+    }
+    /**
+     * Fetch all roles for the guild
+     */
+    async fetchAll() {
+        const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/roles`);
+        const roles = new Collection_1.Collection();
+        for (const roleData of data) {
+            const role = this._add(roleData);
+            roles.set(role.id, role);
+        }
+        return roles;
+    }
+    /**
+     * Create a new role
+     */
+    async create(options) {
+        const body = {};
+        if (options?.name)
+            body.name = options.name;
+        if (options?.color !== undefined) {
+            body.color = typeof options.color === 'string'
+                ? parseInt(options.color.replace('#', ''), 16)
+                : options.color;
+        }
+        if (options?.hoist !== undefined)
+            body.hoist = options.hoist;
+        if (options?.permissions !== undefined)
+            body.permissions = String(options.permissions);
+        if (options?.mentionable !== undefined)
+            body.mentionable = options.mentionable;
+        if (options?.icon)
+            body.icon = options.icon;
+        if (options?.unicodeEmoji)
+            body.unicode_emoji = options.unicodeEmoji;
+        const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/roles`, body);
+        const role = this._add(data);
+        // Set position if specified
+        if (options?.position !== undefined) {
+            await this.setPositions([{ role: role.id, position: options.position }]);
+        }
+        return role;
+    }
+    /**
+     * Delete a role
+     */
+    async delete(id, reason) {
+        await this.client.rest.request('DELETE', `/guilds/${this.guild.id}/roles/${id}`, reason ? { reason } : undefined);
+        this.cache.delete(id);
+    }
+    /**
+     * Edit a role
+     */
+    async edit(id, data) {
+        const body = {};
+        if (data.name !== undefined)
+            body.name = data.name;
+        if (data.color !== undefined) {
+            body.color = typeof data.color === 'string'
+                ? parseInt(data.color.replace('#', ''), 16)
+                : data.color;
+        }
+        if (data.hoist !== undefined)
+            body.hoist = data.hoist;
+        if (data.permissions !== undefined)
+            body.permissions = String(data.permissions);
+        if (data.mentionable !== undefined)
+            body.mentionable = data.mentionable;
+        if (data.icon !== undefined)
+            body.icon = data.icon;
+        if (data.unicodeEmoji !== undefined)
+            body.unicode_emoji = data.unicodeEmoji;
+        const result = await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/roles/${id}`, body);
+        return this._add(result);
+    }
+    /**
+     * Set role positions
+     */
+    async setPositions(positions) {
+        const body = positions.map(p => ({ id: p.role, position: p.position }));
+        const data = await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/roles`, body);
+        const roles = new Collection_1.Collection();
+        for (const roleData of data) {
+            const role = this._add(roleData);
+            roles.set(role.id, role);
+        }
+        return roles;
+    }
+    /**
+     * Compare two roles by position
+     */
+    comparePositions(role1, role2) {
+        const r1 = typeof role1 === 'string' ? this.cache.get(role1) : role1;
+        const r2 = typeof role2 === 'string' ? this.cache.get(role2) : role2;
+        return (r1?.position ?? 0) - (r2?.position ?? 0);
+    }
+}
+exports.RoleManager = RoleManager;
+exports.default = RoleManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RoleManager.js","sourceRoot":"","sources":["../../src/managers/RoleManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Manager for roles with caching and lazy loading\r\n */\r\n\r\nimport { CachedManager } from './BaseManager';\r\nimport { Collection } from '../utils/Collection';\r\n\r\n/**\r\n * Manages roles for a guild\r\n */\r\nexport class RoleManager extends CachedManager<string, any> {\r\n  /** The guild this manager belongs to */\r\n  public readonly guild: any;\r\n\r\n  constructor(guild: any, iterable?: Iterable<any>) {\r\n    super(guild.client, Object as any, iterable);\r\n    this.guild = guild;\r\n  }\r\n\r\n  /**\r\n   * Get the @everyone role\r\n   */\r\n  get everyone(): any {\r\n    return this.cache.get(this.guild.id) ?? null;\r\n  }\r\n\r\n  /**\r\n   * Get the highest role\r\n   */\r\n  get highest(): any {\r\n    return this.cache.reduce((prev, role) => \r\n      (role.position > (prev?.position ?? -1)) ? role : prev\r\n    , null as any);\r\n  }\r\n\r\n  /**\r\n   * Get the bot's highest role\r\n   */\r\n  get botRoleFor(): (userId: string) => any | null {\r\n    return (userId: string) => {\r\n      const member = this.guild.members?.cache.get(userId);\r\n      if (!member) return null;\r\n      return this.cache\r\n        .filter((role: any) => member.roles?.includes(role.id))\r\n        .sort((a: any, b: any) => b.position - a.position)\r\n        .first() ?? null;\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Add a role to the cache\r\n   */\r\n  _add(data: any, cache = true): any {\r\n    const id = data.id;\r\n    const existing = this.cache.get(id);\r\n    \r\n    if (existing) {\r\n      if (cache) Object.assign(existing, data);\r\n      return existing;\r\n    }\r\n    \r\n    const role = {\r\n      id,\r\n      guildId: this.guild.id,\r\n      name: data.name,\r\n      color: data.color ?? 0,\r\n      hoist: data.hoist ?? false,\r\n      position: data.position ?? 0,\r\n      permissions: data.permissions ?? '0',\r\n      managed: data.managed ?? false,\r\n      mentionable: data.mentionable ?? false,\r\n      icon: data.icon ?? null,\r\n      unicodeEmoji: data.unicode_emoji ?? null,\r\n      tags: data.tags ?? null,\r\n      \r\n      get hexColor() {\r\n        return `#${this.color.toString(16).padStart(6, '0')}`;\r\n      },\r\n      \r\n      get createdAt() {\r\n        const timestamp = BigInt(this.id) >> 22n;\r\n        return new Date(Number(timestamp) + 1640995200000); // Jubbio epoch\r\n      },\r\n      \r\n      toString() {\r\n        return this.id === this.guildId ? '@everyone' : `<@&${this.id}>`;\r\n      },\r\n      \r\n      comparePositionTo(role: any) {\r\n        return this.position - (role?.position ?? 0);\r\n      },\r\n      \r\n      async edit(data: any) {\r\n        return this.guild.roles.edit(this.id, data);\r\n      },\r\n      \r\n      async delete(reason?: string) {\r\n        return this.guild.roles.delete(this.id, reason);\r\n      },\r\n      \r\n      async setPosition(position: number) {\r\n        return this.guild.roles.setPositions([{ role: this.id, position }]);\r\n      },\r\n    };\r\n    \r\n    if (cache) this.cache.set(id, role);\r\n    return role;\r\n  }\r\n\r\n  /**\r\n   * Fetch a role from the API\r\n   */\r\n  async fetch(id: string, options?: { cache?: boolean; force?: boolean }): Promise<any> {\r\n    if (!options?.force) {\r\n      const existing = this.cache.get(id);\r\n      if (existing) return existing;\r\n    }\r\n    \r\n    // Roles are fetched as part of guild, so fetch all\r\n    const roles = await this.fetchAll();\r\n    return roles.get(id) ?? null;\r\n  }\r\n\r\n  /**\r\n   * Fetch all roles for the guild\r\n   */\r\n  async fetchAll(): Promise<Collection<string, any>> {\r\n    const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/roles`);\r\n    const roles = new Collection<string, any>();\r\n    for (const roleData of data) {\r\n      const role = this._add(roleData);\r\n      roles.set(role.id, role);\r\n    }\r\n    return roles;\r\n  }\r\n\r\n  /**\r\n   * Create a new role\r\n   */\r\n  async create(options?: {\r\n    name?: string;\r\n    color?: number | string;\r\n    hoist?: boolean;\r\n    position?: number;\r\n    permissions?: string | bigint;\r\n    mentionable?: boolean;\r\n    icon?: string;\r\n    unicodeEmoji?: string;\r\n    reason?: string;\r\n  }): Promise<any> {\r\n    const body: any = {};\r\n    if (options?.name) body.name = options.name;\r\n    if (options?.color !== undefined) {\r\n      body.color = typeof options.color === 'string' \r\n        ? parseInt(options.color.replace('#', ''), 16) \r\n        : options.color;\r\n    }\r\n    if (options?.hoist !== undefined) body.hoist = options.hoist;\r\n    if (options?.permissions !== undefined) body.permissions = String(options.permissions);\r\n    if (options?.mentionable !== undefined) body.mentionable = options.mentionable;\r\n    if (options?.icon) body.icon = options.icon;\r\n    if (options?.unicodeEmoji) body.unicode_emoji = options.unicodeEmoji;\r\n    \r\n    const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/roles`, body);\r\n    const role = this._add(data);\r\n    \r\n    // Set position if specified\r\n    if (options?.position !== undefined) {\r\n      await this.setPositions([{ role: role.id, position: options.position }]);\r\n    }\r\n    \r\n    return role;\r\n  }\r\n\r\n  /**\r\n   * Delete a role\r\n   */\r\n  async delete(id: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request('DELETE', `/guilds/${this.guild.id}/roles/${id}`, \r\n      reason ? { reason } : undefined\r\n    );\r\n    this.cache.delete(id);\r\n  }\r\n\r\n  /**\r\n   * Edit a role\r\n   */\r\n  async edit(id: string, data: {\r\n    name?: string;\r\n    color?: number | string;\r\n    hoist?: boolean;\r\n    position?: number;\r\n    permissions?: string | bigint;\r\n    mentionable?: boolean;\r\n    icon?: string | null;\r\n    unicodeEmoji?: string | null;\r\n    reason?: string;\r\n  }): Promise<any> {\r\n    const body: any = {};\r\n    if (data.name !== undefined) body.name = data.name;\r\n    if (data.color !== undefined) {\r\n      body.color = typeof data.color === 'string' \r\n        ? parseInt(data.color.replace('#', ''), 16) \r\n        : data.color;\r\n    }\r\n    if (data.hoist !== undefined) body.hoist = data.hoist;\r\n    if (data.permissions !== undefined) body.permissions = String(data.permissions);\r\n    if (data.mentionable !== undefined) body.mentionable = data.mentionable;\r\n    if (data.icon !== undefined) body.icon = data.icon;\r\n    if (data.unicodeEmoji !== undefined) body.unicode_emoji = data.unicodeEmoji;\r\n    \r\n    const result = await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/roles/${id}`, body);\r\n    return this._add(result);\r\n  }\r\n\r\n  /**\r\n   * Set role positions\r\n   */\r\n  async setPositions(positions: Array<{ role: string; position: number }>): Promise<Collection<string, any>> {\r\n    const body = positions.map(p => ({ id: p.role, position: p.position }));\r\n    const data = await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/roles`, body);\r\n    \r\n    const roles = new Collection<string, any>();\r\n    for (const roleData of data) {\r\n      const role = this._add(roleData);\r\n      roles.set(role.id, role);\r\n    }\r\n    return roles;\r\n  }\r\n\r\n  /**\r\n   * Compare two roles by position\r\n   */\r\n  comparePositions(role1: string | any, role2: string | any): number {\r\n    const r1 = typeof role1 === 'string' ? this.cache.get(role1) : role1;\r\n    const r2 = typeof role2 === 'string' ? this.cache.get(role2) : role2;\r\n    return (r1?.position ?? 0) - (r2?.position ?? 0);\r\n  }\r\n}\r\n\r\nexport default RoleManager;\r\n"]}

package/dist/managers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Manager exports
+ */
+export * from './BaseManager';
+export * from './GuildMemberManager';
+export * from './ChannelManager';
+export * from './RoleManager';

package/dist/managers/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Manager exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BaseManager"), exports);
+__exportStar(require("./GuildMemberManager"), exports);
+__exportStar(require("./ChannelManager"), exports);
+__exportStar(require("./RoleManager"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWFuYWdlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsZ0RBQThCO0FBQzlCLHVEQUFxQztBQUNyQyxtREFBaUM7QUFDakMsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIE1hbmFnZXIgZXhwb3J0c1xyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vQmFzZU1hbmFnZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL0d1aWxkTWVtYmVyTWFuYWdlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vQ2hhbm5lbE1hbmFnZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL1JvbGVNYW5hZ2VyJztcclxuIl19