@jubbio/core 1.0.0

package/dist/managers/BaseManager.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Base manager class for caching and managing structures
+ */
+import { Collection } from '../utils/Collection';
+/**
+ * Base manager for caching structures
+ */
+export declare abstract class BaseManager<K extends string, V, R = V> {
+    /** The client that instantiated this manager */
+    readonly client: any;
+    /** The cache of items */
+    readonly cache: Collection<K, V>;
+    /** The class to instantiate for items */
+    protected readonly holds: new (...args: any[]) => V;
+    constructor(client: any, holds: new (...args: any[]) => V, iterable?: Iterable<R>);
+    /**
+     * Add an item to the cache
+     */
+    abstract _add(data: any, cache?: boolean, options?: {
+        id?: K;
+        extras?: any[];
+    }): V;
+    /**
+     * Resolve an item from the cache or ID
+     */
+    resolve(idOrInstance: K | V): V | null;
+    /**
+     * Resolve an ID from an item or ID
+     */
+    resolveId(idOrInstance: K | V | {
+        id: K;
+    }): K | null;
+    /**
+     * Get the cache as a JSON array
+     */
+    valueOf(): V[];
+}
+/**
+ * Caching manager that fetches data from the API
+ */
+export declare abstract class CachedManager<K extends string, V, R = V> extends BaseManager<K, V, R> {
+    /**
+     * Fetch an item from the API
+     */
+    abstract fetch(id: K, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<V>;
+    /**
+     * Fetch an item, using cache if available (async version)
+     */
+    resolveAsync(idOrInstance: K | V, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<V | null>;
+}
+/**
+ * Data manager that doesn't cache
+ */
+export declare abstract class DataManager<K extends string, V, R = V> extends BaseManager<K, V, R> {
+    /**
+     * Add an item to the cache
+     */
+    _add(data: any, cache?: boolean, options?: {
+        id?: K;
+        extras?: any[];
+    }): V;
+}
+export default BaseManager;

package/dist/managers/BaseManager.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Base manager class for caching and managing structures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = exports.CachedManager = exports.BaseManager = void 0;
+const Collection_1 = require("../utils/Collection");
+/**
+ * Base manager for caching structures
+ */
+class BaseManager {
+    /** The client that instantiated this manager */
+    client;
+    /** The cache of items */
+    cache;
+    /** The class to instantiate for items */
+    holds;
+    constructor(client, holds, iterable) {
+        this.client = client;
+        this.holds = holds;
+        this.cache = new Collection_1.Collection();
+        if (iterable) {
+            for (const item of iterable) {
+                this._add(item);
+            }
+        }
+    }
+    /**
+     * Resolve an item from the cache or ID
+     */
+    resolve(idOrInstance) {
+        if (idOrInstance instanceof this.holds)
+            return idOrInstance;
+        if (typeof idOrInstance === 'string')
+            return this.cache.get(idOrInstance) ?? null;
+        return null;
+    }
+    /**
+     * Resolve an ID from an item or ID
+     */
+    resolveId(idOrInstance) {
+        if (idOrInstance instanceof this.holds)
+            return idOrInstance.id;
+        if (typeof idOrInstance === 'string')
+            return idOrInstance;
+        if (typeof idOrInstance === 'object' && idOrInstance !== null && 'id' in idOrInstance) {
+            return idOrInstance.id;
+        }
+        return null;
+    }
+    /**
+     * Get the cache as a JSON array
+     */
+    valueOf() {
+        return [...this.cache.values()];
+    }
+}
+exports.BaseManager = BaseManager;
+/**
+ * Caching manager that fetches data from the API
+ */
+class CachedManager extends BaseManager {
+    /**
+     * Fetch an item, using cache if available (async version)
+     */
+    async resolveAsync(idOrInstance, options) {
+        const existing = super.resolve(idOrInstance);
+        if (existing && !options?.force)
+            return existing;
+        const id = this.resolveId(idOrInstance);
+        if (!id)
+            return null;
+        try {
+            return await this.fetch(id, options);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.CachedManager = CachedManager;
+/**
+ * Data manager that doesn't cache
+ */
+class DataManager extends BaseManager {
+    /**
+     * Add an item to the cache
+     */
+    _add(data, cache = true, options) {
+        const existing = this.cache.get(options?.id ?? data.id);
+        if (existing) {
+            if (cache) {
+                existing._patch?.(data);
+            }
+            return existing;
+        }
+        const entry = new this.holds(this.client, data, ...(options?.extras ?? []));
+        if (cache) {
+            this.cache.set(options?.id ?? data.id, entry);
+        }
+        return entry;
+    }
+}
+exports.DataManager = DataManager;
+exports.default = BaseManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/managers/ChannelManager.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Manager for channels with caching and lazy loading
+ */
+import { CachedManager } from './BaseManager';
+import { Collection } from '../utils/Collection';
+/** Channel types */
+export declare enum ChannelType {
+    GuildText = 0,
+    DM = 1,
+    GuildVoice = 2,
+    GroupDM = 3,
+    GuildCategory = 4,
+    GuildAnnouncement = 5,
+    AnnouncementThread = 10,
+    PublicThread = 11,
+    PrivateThread = 12,
+    GuildStageVoice = 13,
+    GuildDirectory = 14,
+    GuildForum = 15
+}
+/**
+ * Manages channels for a guild
+ */
+export declare class GuildChannelManager extends CachedManager<string, any> {
+    /** The guild this manager belongs to */
+    readonly guild: any;
+    constructor(guild: any, iterable?: Iterable<any>);
+    /**
+     * Add a channel to the cache
+     */
+    _add(data: any, cache?: boolean): any;
+    /**
+     * Fetch a channel from the API
+     */
+    fetch(id: string, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<any>;
+    /**
+     * Fetch all channels for the guild
+     */
+    fetchAll(): Promise<Collection<string, any>>;
+    /**
+     * Create a new channel
+     */
+    create(options: {
+        name: string;
+        type?: ChannelType;
+        topic?: string;
+        bitrate?: number;
+        userLimit?: number;
+        rateLimitPerUser?: number;
+        position?: number;
+        permissionOverwrites?: any[];
+        parent?: string;
+        nsfw?: boolean;
+        reason?: string;
+    }): Promise<any>;
+    /**
+     * Delete a channel
+     */
+    delete(id: string, reason?: string): Promise<void>;
+    /**
+     * Edit a channel
+     */
+    edit(id: string, data: {
+        name?: string;
+        type?: ChannelType;
+        position?: number;
+        topic?: string;
+        nsfw?: boolean;
+        rateLimitPerUser?: number;
+        bitrate?: number;
+        userLimit?: number;
+        permissionOverwrites?: any[];
+        parent?: string | null;
+    }): Promise<any>;
+    /**
+     * Set channel positions
+     */
+    setPositions(positions: Array<{
+        channel: string;
+        position: number;
+        parent?: string | null;
+    }>): Promise<void>;
+}
+/**
+ * Global channel manager for the client
+ */
+export declare class ChannelManager extends CachedManager<string, any> {
+    constructor(client: any, iterable?: Iterable<any>);
+    _add(data: any, cache?: boolean): any;
+    fetch(id: string, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<any>;
+}
+export default GuildChannelManager;

package/dist/managers/ChannelManager.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Manager for channels with caching and lazy loading
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = exports.GuildChannelManager = exports.ChannelType = void 0;
+const BaseManager_1 = require("./BaseManager");
+const Collection_1 = require("../utils/Collection");
+/** Channel types */
+var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["GuildText"] = 0] = "GuildText";
+    ChannelType[ChannelType["DM"] = 1] = "DM";
+    ChannelType[ChannelType["GuildVoice"] = 2] = "GuildVoice";
+    ChannelType[ChannelType["GroupDM"] = 3] = "GroupDM";
+    ChannelType[ChannelType["GuildCategory"] = 4] = "GuildCategory";
+    ChannelType[ChannelType["GuildAnnouncement"] = 5] = "GuildAnnouncement";
+    ChannelType[ChannelType["AnnouncementThread"] = 10] = "AnnouncementThread";
+    ChannelType[ChannelType["PublicThread"] = 11] = "PublicThread";
+    ChannelType[ChannelType["PrivateThread"] = 12] = "PrivateThread";
+    ChannelType[ChannelType["GuildStageVoice"] = 13] = "GuildStageVoice";
+    ChannelType[ChannelType["GuildDirectory"] = 14] = "GuildDirectory";
+    ChannelType[ChannelType["GuildForum"] = 15] = "GuildForum";
+})(ChannelType || (exports.ChannelType = ChannelType = {}));
+/**
+ * Manages channels for a guild
+ */
+class GuildChannelManager extends BaseManager_1.CachedManager {
+    /** The guild this manager belongs to */
+    guild;
+    constructor(guild, iterable) {
+        super(guild.client, Object, iterable);
+        this.guild = guild;
+    }
+    /**
+     * Add a channel 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 channel = {
+            id,
+            guildId: this.guild.id,
+            name: data.name,
+            type: data.type,
+            position: data.position ?? 0,
+            parentId: data.parent_id ?? null,
+            permissionOverwrites: data.permission_overwrites ?? [],
+            topic: data.topic ?? null,
+            nsfw: data.nsfw ?? false,
+            rateLimitPerUser: data.rate_limit_per_user ?? 0,
+            bitrate: data.bitrate,
+            userLimit: data.user_limit,
+            get isText() { return [ChannelType.GuildText, ChannelType.GuildAnnouncement].includes(this.type); },
+            get isVoice() { return [ChannelType.GuildVoice, ChannelType.GuildStageVoice].includes(this.type); },
+            get isCategory() { return this.type === ChannelType.GuildCategory; },
+            get isThread() { return [ChannelType.PublicThread, ChannelType.PrivateThread, ChannelType.AnnouncementThread].includes(this.type); },
+            toString() { return `<#${this.id}>`; },
+            async send(content) {
+                return this.guild.client.rest.request('POST', `/channels/${this.id}/messages`, typeof content === 'string' ? { content } : content);
+            },
+            async delete(reason) {
+                return this.guild.client.rest.request('DELETE', `/channels/${this.id}`, reason ? { reason } : undefined);
+            },
+            async edit(data) {
+                return this.guild.client.rest.request('PATCH', `/channels/${this.id}`, data);
+            },
+        };
+        if (cache)
+            this.cache.set(id, channel);
+        return channel;
+    }
+    /**
+     * Fetch a channel 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', `/channels/${id}`);
+        return this._add(data, options?.cache ?? true);
+    }
+    /**
+     * Fetch all channels for the guild
+     */
+    async fetchAll() {
+        const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/channels`);
+        const channels = new Collection_1.Collection();
+        for (const channelData of data) {
+            const channel = this._add(channelData);
+            channels.set(channel.id, channel);
+        }
+        return channels;
+    }
+    /**
+     * Create a new channel
+     */
+    async create(options) {
+        const body = {
+            name: options.name,
+            type: options.type ?? ChannelType.GuildText,
+        };
+        if (options.topic)
+            body.topic = options.topic;
+        if (options.bitrate)
+            body.bitrate = options.bitrate;
+        if (options.userLimit)
+            body.user_limit = options.userLimit;
+        if (options.rateLimitPerUser)
+            body.rate_limit_per_user = options.rateLimitPerUser;
+        if (options.position !== undefined)
+            body.position = options.position;
+        if (options.permissionOverwrites)
+            body.permission_overwrites = options.permissionOverwrites;
+        if (options.parent)
+            body.parent_id = options.parent;
+        if (options.nsfw !== undefined)
+            body.nsfw = options.nsfw;
+        const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/channels`, body);
+        return this._add(data);
+    }
+    /**
+     * Delete a channel
+     */
+    async delete(id, reason) {
+        await this.client.rest.request('DELETE', `/channels/${id}`, reason ? { reason } : undefined);
+        this.cache.delete(id);
+    }
+    /**
+     * Edit a channel
+     */
+    async edit(id, data) {
+        const body = {};
+        if (data.name)
+            body.name = data.name;
+        if (data.type !== undefined)
+            body.type = data.type;
+        if (data.position !== undefined)
+            body.position = data.position;
+        if (data.topic !== undefined)
+            body.topic = data.topic;
+        if (data.nsfw !== undefined)
+            body.nsfw = data.nsfw;
+        if (data.rateLimitPerUser !== undefined)
+            body.rate_limit_per_user = data.rateLimitPerUser;
+        if (data.bitrate !== undefined)
+            body.bitrate = data.bitrate;
+        if (data.userLimit !== undefined)
+            body.user_limit = data.userLimit;
+        if (data.permissionOverwrites)
+            body.permission_overwrites = data.permissionOverwrites;
+        if (data.parent !== undefined)
+            body.parent_id = data.parent;
+        const result = await this.client.rest.request('PATCH', `/channels/${id}`, body);
+        return this._add(result);
+    }
+    /**
+     * Set channel positions
+     */
+    async setPositions(positions) {
+        const body = positions.map(p => ({
+            id: p.channel,
+            position: p.position,
+            parent_id: p.parent,
+        }));
+        await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/channels`, body);
+    }
+}
+exports.GuildChannelManager = GuildChannelManager;
+/**
+ * Global channel manager for the client
+ */
+class ChannelManager extends BaseManager_1.CachedManager {
+    constructor(client, iterable) {
+        super(client, Object, iterable);
+    }
+    _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 channel = { ...data, id };
+        if (cache)
+            this.cache.set(id, channel);
+        return channel;
+    }
+    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', `/channels/${id}`);
+        return this._add(data, options?.cache ?? true);
+    }
+}
+exports.ChannelManager = ChannelManager;
+exports.default = GuildChannelManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChannelManager.js","sourceRoot":"","sources":["../../src/managers/ChannelManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Manager for channels with caching and lazy loading\r\n */\r\n\r\nimport { CachedManager } from './BaseManager';\r\nimport { Collection } from '../utils/Collection';\r\n\r\n/** Channel types */\r\nexport enum ChannelType {\r\n  GuildText = 0,\r\n  DM = 1,\r\n  GuildVoice = 2,\r\n  GroupDM = 3,\r\n  GuildCategory = 4,\r\n  GuildAnnouncement = 5,\r\n  AnnouncementThread = 10,\r\n  PublicThread = 11,\r\n  PrivateThread = 12,\r\n  GuildStageVoice = 13,\r\n  GuildDirectory = 14,\r\n  GuildForum = 15,\r\n}\r\n\r\n/**\r\n * Manages channels for a guild\r\n */\r\nexport class GuildChannelManager 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   * Add a channel 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 channel = {\r\n      id,\r\n      guildId: this.guild.id,\r\n      name: data.name,\r\n      type: data.type,\r\n      position: data.position ?? 0,\r\n      parentId: data.parent_id ?? null,\r\n      permissionOverwrites: data.permission_overwrites ?? [],\r\n      topic: data.topic ?? null,\r\n      nsfw: data.nsfw ?? false,\r\n      rateLimitPerUser: data.rate_limit_per_user ?? 0,\r\n      bitrate: data.bitrate,\r\n      userLimit: data.user_limit,\r\n      \r\n      get isText() { return [ChannelType.GuildText, ChannelType.GuildAnnouncement].includes(this.type); },\r\n      get isVoice() { return [ChannelType.GuildVoice, ChannelType.GuildStageVoice].includes(this.type); },\r\n      get isCategory() { return this.type === ChannelType.GuildCategory; },\r\n      get isThread() { return [ChannelType.PublicThread, ChannelType.PrivateThread, ChannelType.AnnouncementThread].includes(this.type); },\r\n      \r\n      toString() { return `<#${this.id}>`; },\r\n      \r\n      async send(content: any) {\r\n        return this.guild.client.rest.request('POST', `/channels/${this.id}/messages`, \r\n          typeof content === 'string' ? { content } : content\r\n        );\r\n      },\r\n      \r\n      async delete(reason?: string) {\r\n        return this.guild.client.rest.request('DELETE', `/channels/${this.id}`, reason ? { reason } : undefined);\r\n      },\r\n      \r\n      async edit(data: any) {\r\n        return this.guild.client.rest.request('PATCH', `/channels/${this.id}`, data);\r\n      },\r\n    };\r\n    \r\n    if (cache) this.cache.set(id, channel);\r\n    return channel;\r\n  }\r\n\r\n  /**\r\n   * Fetch a channel 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('GET', `/channels/${id}`);\r\n    return this._add(data, options?.cache ?? true);\r\n  }\r\n\r\n  /**\r\n   * Fetch all channels 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}/channels`);\r\n    const channels = new Collection<string, any>();\r\n    for (const channelData of data) {\r\n      const channel = this._add(channelData);\r\n      channels.set(channel.id, channel);\r\n    }\r\n    return channels;\r\n  }\r\n\r\n  /**\r\n   * Create a new channel\r\n   */\r\n  async create(options: {\r\n    name: string;\r\n    type?: ChannelType;\r\n    topic?: string;\r\n    bitrate?: number;\r\n    userLimit?: number;\r\n    rateLimitPerUser?: number;\r\n    position?: number;\r\n    permissionOverwrites?: any[];\r\n    parent?: string;\r\n    nsfw?: boolean;\r\n    reason?: string;\r\n  }): Promise<any> {\r\n    const body: any = {\r\n      name: options.name,\r\n      type: options.type ?? ChannelType.GuildText,\r\n    };\r\n    if (options.topic) body.topic = options.topic;\r\n    if (options.bitrate) body.bitrate = options.bitrate;\r\n    if (options.userLimit) body.user_limit = options.userLimit;\r\n    if (options.rateLimitPerUser) body.rate_limit_per_user = options.rateLimitPerUser;\r\n    if (options.position !== undefined) body.position = options.position;\r\n    if (options.permissionOverwrites) body.permission_overwrites = options.permissionOverwrites;\r\n    if (options.parent) body.parent_id = options.parent;\r\n    if (options.nsfw !== undefined) body.nsfw = options.nsfw;\r\n    \r\n    const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/channels`, body);\r\n    return this._add(data);\r\n  }\r\n\r\n  /**\r\n   * Delete a channel\r\n   */\r\n  async delete(id: string, reason?: string): Promise<void> {\r\n    await this.client.rest.request('DELETE', `/channels/${id}`, reason ? { reason } : undefined);\r\n    this.cache.delete(id);\r\n  }\r\n\r\n  /**\r\n   * Edit a channel\r\n   */\r\n  async edit(id: string, data: {\r\n    name?: string;\r\n    type?: ChannelType;\r\n    position?: number;\r\n    topic?: string;\r\n    nsfw?: boolean;\r\n    rateLimitPerUser?: number;\r\n    bitrate?: number;\r\n    userLimit?: number;\r\n    permissionOverwrites?: any[];\r\n    parent?: string | null;\r\n  }): Promise<any> {\r\n    const body: any = {};\r\n    if (data.name) body.name = data.name;\r\n    if (data.type !== undefined) body.type = data.type;\r\n    if (data.position !== undefined) body.position = data.position;\r\n    if (data.topic !== undefined) body.topic = data.topic;\r\n    if (data.nsfw !== undefined) body.nsfw = data.nsfw;\r\n    if (data.rateLimitPerUser !== undefined) body.rate_limit_per_user = data.rateLimitPerUser;\r\n    if (data.bitrate !== undefined) body.bitrate = data.bitrate;\r\n    if (data.userLimit !== undefined) body.user_limit = data.userLimit;\r\n    if (data.permissionOverwrites) body.permission_overwrites = data.permissionOverwrites;\r\n    if (data.parent !== undefined) body.parent_id = data.parent;\r\n    \r\n    const result = await this.client.rest.request('PATCH', `/channels/${id}`, body);\r\n    return this._add(result);\r\n  }\r\n\r\n  /**\r\n   * Set channel positions\r\n   */\r\n  async setPositions(positions: Array<{ channel: string; position: number; parent?: string | null }>): Promise<void> {\r\n    const body = positions.map(p => ({\r\n      id: p.channel,\r\n      position: p.position,\r\n      parent_id: p.parent,\r\n    }));\r\n    await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/channels`, body);\r\n  }\r\n}\r\n\r\n/**\r\n * Global channel manager for the client\r\n */\r\nexport class ChannelManager extends CachedManager<string, any> {\r\n  constructor(client: any, iterable?: Iterable<any>) {\r\n    super(client, Object as any, iterable);\r\n  }\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    if (existing) {\r\n      if (cache) Object.assign(existing, data);\r\n      return existing;\r\n    }\r\n    \r\n    const channel = { ...data, id };\r\n    if (cache) this.cache.set(id, channel);\r\n    return channel;\r\n  }\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    const data = await this.client.rest.request('GET', `/channels/${id}`);\r\n    return this._add(data, options?.cache ?? true);\r\n  }\r\n}\r\n\r\nexport default GuildChannelManager;\r\n"]}

package/dist/managers/GuildMemberManager.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Manager for guild members with caching and lazy loading
+ */
+import { CachedManager } from './BaseManager';
+import { Collection } from '../utils/Collection';
+/**
+ * Manages guild members
+ */
+export declare class GuildMemberManager extends CachedManager<string, any> {
+    /** The guild this manager belongs to */
+    readonly guild: any;
+    constructor(guild: any, iterable?: Iterable<any>);
+    /**
+     * Add a member to the cache
+     */
+    _add(data: any, cache?: boolean): any;
+    /**
+     * Fetch a member from the API
+     */
+    fetch(id: string, options?: {
+        cache?: boolean;
+        force?: boolean;
+    }): Promise<any>;
+    /**
+     * Fetch multiple members
+     */
+    fetchMany(options?: {
+        limit?: number;
+        after?: string;
+        query?: string;
+    }): Promise<Collection<string, any>>;
+    /**
+     * Search for members by query
+     */
+    search(options: {
+        query: string;
+        limit?: number;
+    }): Promise<Collection<string, any>>;
+    /**
+     * Kick a member
+     */
+    kick(id: string, reason?: string): Promise<void>;
+    /**
+     * Ban a member
+     */
+    ban(id: string, options?: {
+        deleteMessageDays?: number;
+        reason?: string;
+    }): Promise<void>;
+    /**
+     * Unban a user
+     */
+    unban(id: string, reason?: string): Promise<void>;
+    /**
+     * Edit a member
+     */
+    edit(id: string, data: {
+        nick?: string | null;
+        roles?: string[];
+        mute?: boolean;
+        deaf?: boolean;
+        channel_id?: string | null;
+        communication_disabled_until?: Date | null;
+    }): Promise<any>;
+    /**
+     * Add a role to a member
+     */
+    addRole(memberId: string, roleId: string, reason?: string): Promise<void>;
+    /**
+     * Remove a role from a member
+     */
+    removeRole(memberId: string, roleId: string, reason?: string): Promise<void>;
+}
+export default GuildMemberManager;