baff.js 0.0.0-stage → 0.1.1

package/dist/esm/http/verify.js

@@ -0,0 +1,22 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export const SIGNATURE_HEADERS = ['x-bafflux-signature', 'x-baff.gg-signature'];
+export const TIMESTAMP_HEADERS = ['x-bafflux-timestamp', 'x-baff.gg-timestamp'];
+export function sign(secret, timestamp, body) {
+    return createHmac('sha256', secret).update(`${timestamp}.`).update(body).digest('hex');
+}
+export function verifyKey(body, signature, timestamp, secret, options = {}) {
+    if (!signature || !timestamp || !secret)
+        return false;
+    if (!/^\d{1,12}$/.test(timestamp))
+        return false;
+    const now = (options.now ?? Date.now)() / 1000;
+    if (Math.abs(now - Number(timestamp)) > (options.toleranceSeconds ?? 300))
+        return false;
+    const expected = Buffer.from(sign(secret, timestamp, body), 'hex');
+    const given = Buffer.from(signature, 'hex');
+    return given.length === expected.length && timingSafeEqual(given, expected);
+}
+export function verifyRequestHeaders(headers, body, secret, options) {
+    const find = (names) => names.map((name) => headers.get(name)).find((value) => value !== null) ?? null;
+    return verifyKey(body, find(SIGNATURE_HEADERS), find(TIMESTAMP_HEADERS), secret, options);
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,51 @@
+export { Client, ClientApplication, type ClientOptions } from './client/Client.js';
+export type { ClientEvents, MemberRemoval, MentionEvent, MessageDeleteEvent, MessagePinEvent, PresenceEvent, ReactionEvent, ServerRemoval, TypingEvent } from './client/events.js';
+export { REST, bucketKey, type HTTPMethod, type RateLimitInfo, type RequestOptions, type RESTOptions } from './rest/REST.js';
+export { Routes } from './rest/Routes.js';
+export { AttachmentBuilder, type FileData, type RawFile } from './rest/files.js';
+export { Gateway, type GatewayOptions, type WebSocketConstructor, type WebSocketLike } from './gateway/Gateway.js';
+export { BaffAPIError, BaffError, BaffRateLimitError } from './errors/BaffError.js';
+export { Collection } from './util/Collection.js';
+export { Snowflake, type DeconstructedSnowflake, type SnowflakeParts } from './util/Snowflake.js';
+export { PermissionFlagsBits, PermissionsBitField, type PermissionResolvable, type PermissionString } from './util/Permissions.js';
+export * from './util/formatters.js';
+export { resolveEmoji, type EmojiResolvable } from './util/emoji.js';
+export { ApplicationCommandOptionType, ButtonStyle, ChannelType, Colors, ComponentType, DEFAULT_API_URL, DEFAULT_GATEWAY_URL, MessageFlags, PresenceStatus, SeparatorSpacing, TextInputStyle, VERSION } from './util/constants.js';
+export { EmbedBuilder, EmbedLimits, resolveColor, type ColorResolvable } from './builders/EmbedBuilder.js';
+export { ActionRowBuilder } from './builders/components/ActionRowBuilder.js';
+export { ButtonBuilder } from './builders/components/ButtonBuilder.js';
+export { ChannelSelectMenuBuilder, MentionableSelectMenuBuilder, RoleSelectMenuBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, UserSelectMenuBuilder, type SelectOptionData } from './builders/components/SelectMenuBuilder.js';
+export { ModalBuilder, TextInputBuilder } from './builders/components/ModalBuilder.js';
+export { ContainerBuilder, MediaGalleryBuilder, MediaGalleryItemBuilder, SectionBuilder, SeparatorBuilder, TextDisplayBuilder, ThumbnailBuilder } from './builders/components/LayoutBuilders.js';
+export { BooleanOption, ChannelOption, IntegerOption, NumberOption, PrefixCommandBuilder, RoleOption, SlashCommandBuilder, StringOption, SubcommandBuilder, SubcommandGroupBuilder, UserOption } from './builders/SlashCommandBuilder.js';
+export { checkComponents, resolveEmbeds, resolveMessage, type MessageOptions, type PollData, type ResolvedMessage } from './builders/messagePayload.js';
+export { Collector, CollectorError, awaitCollector, type CollectorOptions } from './collectors/Collector.js';
+export { InteractionCollector, type InteractionCollectorOptions } from './collectors/InteractionCollector.js';
+export { MessageCollector, type AwaitMessagesOptions, type MessageCollectorOptions } from './collectors/MessageCollector.js';
+export { createInteractionsHandler, toNodeListener, type InteractionsHandler, type InteractionsHandlerOptions } from './http/handler.js';
+export { sign as signInteractionBody, verifyKey, verifyRequestHeaders, type VerifyOptions } from './http/verify.js';
+export { CachedManager, type FetchOptions } from './managers/CachedManager.js';
+export { ApplicationCommand, ApplicationCommandManager } from './managers/CommandManager.js';
+export { MessageManager, type FetchMessagesOptions } from './managers/MessageManager.js';
+export { MemberManager, type Ban } from './managers/MemberManager.js';
+export { RoleManager } from './managers/RoleManager.js';
+export { ServerChannelManager, type CreateChannelOptions } from './managers/ServerChannelManager.js';
+export { InviteManager, type CreateInviteOptions } from './managers/InviteManager.js';
+export { BaseChannel, type ChannelEditData } from './structures/channels/BaseChannel.js';
+export { DMChannel } from './structures/channels/DMChannel.js';
+export { CategoryChannel, ForumChannel, TextChannel, ThreadChannel, VoiceChannel, createChannel, type Channel, type ServerChannel } from './structures/channels/ServerChannels.js';
+export { TextBasedChannel } from './structures/channels/TextBasedChannel.js';
+export { BaseInteraction, type InteractionReplyOptions } from './structures/interactions/BaseInteraction.js';
+export { ChatInputCommandInteraction, CommandInteractionOptions } from './structures/interactions/CommandInteraction.js';
+export { ButtonInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, MessageComponentInteraction, RoleSelectMenuInteraction, SelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction } from './structures/interactions/ComponentInteraction.js';
+export { ModalSubmitFields, ModalSubmitInteraction } from './structures/interactions/ModalSubmitInteraction.js';
+export { createInteraction } from './structures/interactions/createInteraction.js';
+export { Message, MessageMentions, MessageReaction } from './structures/Message.js';
+export { Role, type RoleEditData } from './structures/Role.js';
+export { ScheduledEvent, type ScheduledEventData } from './structures/ScheduledEvent.js';
+export { Server, type AuditLogEntry, type AuditLogQuery, type ServerEditData } from './structures/Server.js';
+export { Emoji, Invite, Sticker } from './structures/ServerAssets.js';
+export { MemberRoleManager, ServerMember } from './structures/ServerMember.js';
+export { ClientUser, User } from './structures/User.js';
+export { Webhook, WebhookClient, type WebhookMessageOptions } from './structures/Webhook.js';
+export type * from './types.js';

package/dist/esm/index.js

@@ -0,0 +1,49 @@
+export { Client, ClientApplication } from './client/Client.js';
+export { REST, bucketKey } from './rest/REST.js';
+export { Routes } from './rest/Routes.js';
+export { AttachmentBuilder } from './rest/files.js';
+export { Gateway } from './gateway/Gateway.js';
+export { BaffAPIError, BaffError, BaffRateLimitError } from './errors/BaffError.js';
+export { Collection } from './util/Collection.js';
+export { Snowflake } from './util/Snowflake.js';
+export { PermissionFlagsBits, PermissionsBitField } from './util/Permissions.js';
+export * from './util/formatters.js';
+export { resolveEmoji } from './util/emoji.js';
+export { ApplicationCommandOptionType, ButtonStyle, ChannelType, Colors, ComponentType, DEFAULT_API_URL, DEFAULT_GATEWAY_URL, MessageFlags, PresenceStatus, SeparatorSpacing, TextInputStyle, VERSION } from './util/constants.js';
+export { EmbedBuilder, EmbedLimits, resolveColor } from './builders/EmbedBuilder.js';
+export { ActionRowBuilder } from './builders/components/ActionRowBuilder.js';
+export { ButtonBuilder } from './builders/components/ButtonBuilder.js';
+export { ChannelSelectMenuBuilder, MentionableSelectMenuBuilder, RoleSelectMenuBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, UserSelectMenuBuilder } from './builders/components/SelectMenuBuilder.js';
+export { ModalBuilder, TextInputBuilder } from './builders/components/ModalBuilder.js';
+export { ContainerBuilder, MediaGalleryBuilder, MediaGalleryItemBuilder, SectionBuilder, SeparatorBuilder, TextDisplayBuilder, ThumbnailBuilder } from './builders/components/LayoutBuilders.js';
+export { BooleanOption, ChannelOption, IntegerOption, NumberOption, PrefixCommandBuilder, RoleOption, SlashCommandBuilder, StringOption, SubcommandBuilder, SubcommandGroupBuilder, UserOption } from './builders/SlashCommandBuilder.js';
+export { checkComponents, resolveEmbeds, resolveMessage } from './builders/messagePayload.js';
+export { Collector, CollectorError, awaitCollector } from './collectors/Collector.js';
+export { InteractionCollector } from './collectors/InteractionCollector.js';
+export { MessageCollector } from './collectors/MessageCollector.js';
+export { createInteractionsHandler, toNodeListener } from './http/handler.js';
+export { sign as signInteractionBody, verifyKey, verifyRequestHeaders } from './http/verify.js';
+export { CachedManager } from './managers/CachedManager.js';
+export { ApplicationCommand, ApplicationCommandManager } from './managers/CommandManager.js';
+export { MessageManager } from './managers/MessageManager.js';
+export { MemberManager } from './managers/MemberManager.js';
+export { RoleManager } from './managers/RoleManager.js';
+export { ServerChannelManager } from './managers/ServerChannelManager.js';
+export { InviteManager } from './managers/InviteManager.js';
+export { BaseChannel } from './structures/channels/BaseChannel.js';
+export { DMChannel } from './structures/channels/DMChannel.js';
+export { CategoryChannel, ForumChannel, TextChannel, ThreadChannel, VoiceChannel, createChannel } from './structures/channels/ServerChannels.js';
+export { TextBasedChannel } from './structures/channels/TextBasedChannel.js';
+export { BaseInteraction } from './structures/interactions/BaseInteraction.js';
+export { ChatInputCommandInteraction, CommandInteractionOptions } from './structures/interactions/CommandInteraction.js';
+export { ButtonInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, MessageComponentInteraction, RoleSelectMenuInteraction, SelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction } from './structures/interactions/ComponentInteraction.js';
+export { ModalSubmitFields, ModalSubmitInteraction } from './structures/interactions/ModalSubmitInteraction.js';
+export { createInteraction } from './structures/interactions/createInteraction.js';
+export { Message, MessageMentions, MessageReaction } from './structures/Message.js';
+export { Role } from './structures/Role.js';
+export { ScheduledEvent } from './structures/ScheduledEvent.js';
+export { Server } from './structures/Server.js';
+export { Emoji, Invite, Sticker } from './structures/ServerAssets.js';
+export { MemberRoleManager, ServerMember } from './structures/ServerMember.js';
+export { ClientUser, User } from './structures/User.js';
+export { Webhook, WebhookClient } from './structures/Webhook.js';

package/dist/esm/managers/CachedManager.d.ts

@@ -0,0 +1,16 @@
+import type { Client } from '../client/Client.js';
+import { Collection } from '../util/Collection.js';
+export declare abstract class CachedManager<V extends {
+    id: string;
+}> {
+    readonly client: Client;
+    readonly cache: Collection<string, V>;
+    constructor(client: Client);
+    resolve(target: string | V): V | null;
+    resolveId(target: string | {
+        id: string;
+    }): string;
+}
+export interface FetchOptions {
+    force?: boolean;
+}

package/dist/esm/managers/CachedManager.js

@@ -0,0 +1,14 @@
+import { Collection } from '../util/Collection.js';
+export class CachedManager {
+    client;
+    cache = new Collection();
+    constructor(client) {
+        this.client = client;
+    }
+    resolve(target) {
+        return typeof target === 'string' ? (this.cache.get(target) ?? null) : target;
+    }
+    resolveId(target) {
+        return typeof target === 'string' ? target : target.id;
+    }
+}

package/dist/esm/managers/ChannelManager.d.ts

@@ -0,0 +1,23 @@
+import { DMChannel } from '../structures/channels/DMChannel.js';
+import { ThreadChannel, type Channel, type ServerChannel } from '../structures/channels/ServerChannels.js';
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import type { APIChannel } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export declare class ChannelManager extends CachedManager<Channel> {
+    private readonly byServer;
+    forServer(serverId: string): Collection<string, ServerChannel>;
+    _set(channel: Channel): Channel;
+    _upsert(data: APIChannel): Channel;
+    _remove(id: string): Channel | null;
+    _replaceServer(serverId: string, list: APIChannel[]): {
+        created: Channel[];
+        updated: [Channel, Channel][];
+        deleted: Channel[];
+    };
+    _addDM(data: APIChannel): DMChannel;
+    _addThread(data: APIChannel): ThreadChannel;
+    _textChannel(id: string, serverId: string | null): TextBasedChannel;
+    fetchDMs(): Promise<Collection<string, DMChannel>>;
+    fetch(id: string, options?: FetchOptions): Promise<Channel>;
+}

package/dist/esm/managers/ChannelManager.js

@@ -0,0 +1,81 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Routes } from '../rest/Routes.js';
+import { createChannel, ThreadChannel } from '../structures/channels/ServerChannels.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+export class ChannelManager extends CachedManager {
+    byServer = new Map();
+    forServer(serverId) {
+        let list = this.byServer.get(serverId);
+        if (!list)
+            this.byServer.set(serverId, (list = new Collection()));
+        return list;
+    }
+    _set(channel) {
+        this.cache.set(channel.id, channel);
+        if (channel.serverId)
+            this.forServer(channel.serverId).set(channel.id, channel);
+        return channel;
+    }
+    _upsert(data) {
+        const existing = this.cache.get(data.id);
+        if (existing && (data.kind ?? data.type ?? existing.kind) === existing.kind)
+            return existing._patch(data);
+        return this._set(createChannel(this.client, data));
+    }
+    _remove(id) {
+        const channel = this.cache.get(id) ?? null;
+        this.cache.delete(id);
+        if (channel?.serverId)
+            this.forServer(channel.serverId).delete(id);
+        return channel;
+    }
+    _replaceServer(serverId, list) {
+        const seen = new Set();
+        const created = [];
+        const updated = [];
+        for (const data of list) {
+            const withServer = { ...data, serverId };
+            seen.add(data.id);
+            const existing = this.cache.get(data.id);
+            if (!existing) {
+                created.push(this._upsert(withServer));
+                continue;
+            }
+            const before = existing._clone();
+            updated.push([before, this._upsert(withServer)]);
+        }
+        const deleted = [];
+        for (const [id, channel] of this.forServer(serverId)) {
+            if (!seen.has(id) && !(channel instanceof ThreadChannel))
+                deleted.push(this._remove(id));
+        }
+        return { created, updated, deleted };
+    }
+    _addDM(data) {
+        return this._upsert({ ...data, serverId: null });
+    }
+    _addThread(data) {
+        return this._upsert(data);
+    }
+    _textChannel(id, serverId) {
+        const cached = this.cache.get(id);
+        if (cached?.isTextBased())
+            return cached;
+        return this._set(createChannel(this.client, { id, kind: serverId ? 'text' : 'dm', serverId }));
+    }
+    async fetchDMs() {
+        const list = await this.client.rest.get(Routes.dms());
+        return new Collection(list.map((data) => [data.id, this._addDM(data)]));
+    }
+    async fetch(id, options = {}) {
+        const cached = this.cache.get(id);
+        if (cached && !options.force)
+            return cached;
+        await Promise.all([this.client.servers.fetch(undefined, { force: true }), this.fetchDMs()]);
+        const channel = this.cache.get(id);
+        if (!channel)
+            throw new BaffError('UNKNOWN_CHANNEL', `Channel ${id} was not found in the servers or DMs this bot can see.`);
+        return channel;
+    }
+}

package/dist/esm/managers/CommandManager.d.ts

@@ -0,0 +1,32 @@
+import type { Client } from '../client/Client.js';
+import { type Serializable } from '../builders/validate.js';
+import { Identified } from '../structures/Base.js';
+import type { APICommand } from '../types.js';
+import { Collection } from '../util/Collection.js';
+export declare class ApplicationCommand extends Identified {
+    private readonly manager;
+    readonly id: string;
+    readonly applicationId: string;
+    readonly serverId: string | null;
+    readonly kind: 'slash' | 'prefix';
+    readonly name: string;
+    readonly description: string;
+    readonly options: NonNullable<APICommand['options']>;
+    readonly prefix: string | null;
+    constructor(client: Client, data: APICommand, manager: ApplicationCommandManager);
+    delete(): Promise<void>;
+    toString(): string;
+}
+export declare class ApplicationCommandManager {
+    private readonly client;
+    private readonly appId;
+    readonly serverId: string | null;
+    readonly cache: Collection<string, ApplicationCommand>;
+    constructor(client: Client, appId: () => string, serverId?: string | null);
+    get applicationId(): string;
+    private get path();
+    private load;
+    fetch(): Promise<Collection<string, ApplicationCommand>>;
+    set(commands: (Serializable | APICommand)[]): Promise<Collection<string, ApplicationCommand>>;
+    delete(commandId: string): Promise<void>;
+}

package/dist/esm/managers/CommandManager.js

@@ -0,0 +1,67 @@
+import { resolveJSON } from '../builders/validate.js';
+import { Routes } from '../rest/Routes.js';
+import { Identified } from '../structures/Base.js';
+import { Collection } from '../util/Collection.js';
+export class ApplicationCommand extends Identified {
+    manager;
+    id;
+    applicationId;
+    serverId;
+    kind;
+    name;
+    description;
+    options;
+    prefix;
+    constructor(client, data, manager) {
+        super(client);
+        this.manager = manager;
+        this.id = data.id;
+        this.applicationId = data.applicationId ?? manager.applicationId;
+        this.serverId = data.serverId ?? null;
+        this.kind = data.kind ?? 'slash';
+        this.name = data.name;
+        this.description = data.description;
+        this.options = data.options ?? [];
+        this.prefix = data.prefix ?? null;
+    }
+    delete() {
+        return this.manager.delete(this.id);
+    }
+    toString() {
+        return this.kind === 'prefix' ? `${this.prefix}${this.name}` : `/${this.name}`;
+    }
+}
+export class ApplicationCommandManager {
+    client;
+    appId;
+    serverId;
+    cache = new Collection();
+    constructor(client, appId, serverId = null) {
+        this.client = client;
+        this.appId = appId;
+        this.serverId = serverId;
+    }
+    get applicationId() {
+        return this.appId();
+    }
+    get path() {
+        return this.serverId ? Routes.serverCommands(this.applicationId, this.serverId) : Routes.applicationCommands(this.applicationId);
+    }
+    load(list) {
+        this.cache.clear();
+        for (const data of list)
+            this.cache.set(data.id, new ApplicationCommand(this.client, data, this));
+        return this.cache;
+    }
+    async fetch() {
+        return this.load(await this.client.rest.get(this.path));
+    }
+    async set(commands) {
+        const body = commands.map((c) => resolveJSON(c));
+        return this.load(await this.client.rest.put(this.path, { body }));
+    }
+    async delete(commandId) {
+        await this.client.rest.delete(Routes.applicationCommand(this.applicationId, commandId));
+        this.cache.delete(commandId);
+    }
+}

package/dist/esm/managers/EventManager.d.ts

@@ -0,0 +1,15 @@
+import type { Client } from '../client/Client.js';
+import { ScheduledEvent, type ScheduledEventData } from '../structures/ScheduledEvent.js';
+import type { APIServerEvent } from '../types.js';
+import { CachedManager } from './CachedManager.js';
+import type { Collection } from '../util/Collection.js';
+export declare class EventManager extends CachedManager<ScheduledEvent> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIServerEvent): ScheduledEvent;
+    fetch(): Promise<Collection<string, ScheduledEvent>>;
+    create(data: Required<Pick<ScheduledEventData, 'name' | 'locationKind' | 'startAt'>> & ScheduledEventData): Promise<ScheduledEvent>;
+    delete(event: string | {
+        id: string;
+    }): Promise<void>;
+}

package/dist/esm/managers/EventManager.js

@@ -0,0 +1,32 @@
+import { Routes } from '../rest/Routes.js';
+import { eventBody, ScheduledEvent } from '../structures/ScheduledEvent.js';
+import { CachedManager } from './CachedManager.js';
+export class EventManager extends CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const existing = this.cache.get(data.id);
+        if (existing)
+            return existing._patch(data);
+        const event = new ScheduledEvent(this.client, data);
+        this.cache.set(event.id, event);
+        return event;
+    }
+    async fetch() {
+        const list = await this.client.rest.get(Routes.serverEvents(this.serverId));
+        this.cache.clear();
+        list.forEach((data) => this._add(data));
+        return this.cache;
+    }
+    async create(data) {
+        return this._add(await this.client.rest.post(Routes.serverEvents(this.serverId), { body: eventBody(data) }));
+    }
+    async delete(event) {
+        const id = this.resolveId(event);
+        await this.client.rest.delete(Routes.serverEvent(this.serverId, id));
+        this.cache.delete(id);
+    }
+}

package/dist/esm/managers/ExpressionManagers.d.ts

@@ -0,0 +1,36 @@
+import type { Client } from '../client/Client.js';
+import { AttachmentBuilder, type FileData } from '../rest/files.js';
+import { Emoji, Sticker } from '../structures/ServerAssets.js';
+import type { APIEmoji, APISticker } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+type Upload = FileData | AttachmentBuilder;
+export declare class EmojiManager extends CachedManager<Emoji> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIEmoji): Emoji;
+    fetch(): Promise<Collection<string, Emoji>>;
+    create(options: {
+        name: string;
+        attachment: Upload;
+    }): Promise<Emoji>;
+    delete(emoji: string | {
+        id: string;
+    }): Promise<void>;
+}
+export declare class StickerManager extends CachedManager<Sticker> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _setAll(list: APISticker[]): void;
+    fetch(): Promise<Collection<string, Sticker>>;
+    create(options: {
+        name: string;
+        description?: string;
+        emoji: string;
+        file: Upload;
+    }): Promise<Sticker>;
+    delete(sticker: string | {
+        id: string;
+    }): Promise<void>;
+}
+export {};

package/dist/esm/managers/ExpressionManagers.js

@@ -0,0 +1,68 @@
+import { AttachmentBuilder, toBlob } from '../rest/files.js';
+import { Routes } from '../rest/Routes.js';
+import { Emoji, Sticker } from '../structures/ServerAssets.js';
+import { CachedManager } from './CachedManager.js';
+function fileForm(fields, upload) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields))
+        if (value !== undefined)
+            form.append(key, value);
+    const file = upload instanceof AttachmentBuilder ? upload.toFile() : { name: 'file', data: upload };
+    form.append('file', toBlob(file), file.name);
+    return form;
+}
+export class EmojiManager extends CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const emoji = new Emoji(this.client, { ...data, serverId: this.serverId });
+        this.cache.set(emoji.id, emoji);
+        return emoji;
+    }
+    async fetch() {
+        const list = await this.client.rest.get(Routes.serverEmojis(this.serverId));
+        this.cache.clear();
+        list.forEach((data) => this._add(data));
+        return this.cache;
+    }
+    async create(options) {
+        const data = await this.client.rest.post(Routes.serverEmojis(this.serverId), { body: fileForm({ name: options.name }, options.attachment) });
+        return this._add(data);
+    }
+    async delete(emoji) {
+        const id = this.resolveId(emoji);
+        await this.client.rest.delete(Routes.serverEmoji(this.serverId, id));
+        this.cache.delete(id);
+    }
+}
+export class StickerManager extends CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _setAll(list) {
+        this.cache.clear();
+        for (const data of list)
+            this.cache.set(data.id, new Sticker(this.client, data, this.serverId));
+    }
+    async fetch() {
+        this._setAll(await this.client.rest.get(Routes.serverStickers(this.serverId)));
+        return this.cache;
+    }
+    async create(options) {
+        const form = fileForm({ name: options.name, description: options.description ?? '', emoji: options.emoji }, options.file);
+        const data = await this.client.rest.post(Routes.serverStickers(this.serverId), { body: form });
+        const sticker = new Sticker(this.client, data, this.serverId);
+        this.cache.set(sticker.id, sticker);
+        return sticker;
+    }
+    async delete(sticker) {
+        const id = this.resolveId(sticker);
+        await this.client.rest.delete(Routes.serverSticker(this.serverId, id));
+        this.cache.delete(id);
+    }
+}

package/dist/esm/managers/InviteManager.d.ts

@@ -0,0 +1,17 @@
+import type { Client } from '../client/Client.js';
+import { Invite } from '../structures/ServerAssets.js';
+import { Collection } from '../util/Collection.js';
+export interface CreateInviteOptions {
+    maxAgeSecs?: number;
+    maxUses?: number;
+    temporary?: boolean;
+    unique?: boolean;
+}
+export declare class InviteManager {
+    private readonly client;
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    create(options?: CreateInviteOptions): Promise<Invite>;
+    fetch(): Promise<Collection<string, Invite>>;
+    delete(code: string | Invite): Promise<void>;
+}

package/dist/esm/managers/InviteManager.js

@@ -0,0 +1,22 @@
+import { Routes } from '../rest/Routes.js';
+import { Invite } from '../structures/ServerAssets.js';
+import { Collection } from '../util/Collection.js';
+export class InviteManager {
+    client;
+    serverId;
+    constructor(client, serverId) {
+        this.client = client;
+        this.serverId = serverId;
+    }
+    async create(options = {}) {
+        const data = await this.client.rest.post(Routes.serverInvites(this.serverId), { body: options });
+        return new Invite(this.client, data, this.serverId);
+    }
+    async fetch() {
+        const list = await this.client.rest.get(Routes.serverInvites(this.serverId));
+        return new Collection(list.map((data) => [data.code, new Invite(this.client, data, this.serverId)]));
+    }
+    async delete(code) {
+        await this.client.rest.delete(Routes.serverInvite(this.serverId, typeof code === 'string' ? code : code.code));
+    }
+}

package/dist/esm/managers/MemberManager.d.ts

@@ -0,0 +1,31 @@
+import type { Client } from '../client/Client.js';
+import { ServerMember } from '../structures/ServerMember.js';
+import type { User } from '../structures/User.js';
+import type { APIMember } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export interface Ban {
+    user: User;
+    reason: string | null;
+    createdAt: Date;
+}
+export declare class MemberManager extends CachedManager<ServerMember> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIMember): ServerMember;
+    get me(): ServerMember | null;
+    fetch(): Promise<Collection<string, ServerMember>>;
+    fetch(userId: string, options?: FetchOptions): Promise<ServerMember>;
+    kick(user: string | {
+        id: string;
+    }, reason?: string): Promise<void>;
+    ban(user: string | {
+        id: string;
+    }, options?: {
+        reason?: string;
+    }): Promise<void>;
+    unban(user: string | {
+        id: string;
+    }): Promise<void>;
+    fetchBans(): Promise<Collection<string, Ban>>;
+}

package/dist/esm/managers/MemberManager.js

@@ -0,0 +1,58 @@
+import { BaffError } from '../errors/BaffError.js';
+import { Routes } from '../rest/Routes.js';
+import { ServerMember } from '../structures/ServerMember.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+export class MemberManager extends CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const user = this.client.users._add({ ...data.user, status: data.status ?? data.user.status, customStatus: data.customStatus ?? data.user.customStatus });
+        const existing = this.cache.get(user.id);
+        if (existing)
+            return existing._patch(data);
+        const member = new ServerMember(this.client, this.serverId, user, data);
+        this.cache.set(user.id, member);
+        return member;
+    }
+    get me() {
+        const id = this.client.user?.id;
+        return id ? (this.cache.get(id) ?? null) : null;
+    }
+    async fetch(userId, options = {}) {
+        if (userId !== undefined) {
+            const cached = this.cache.get(userId);
+            if (cached && !options.force)
+                return cached;
+        }
+        const list = await this.client.rest.get(Routes.serverMembers(this.serverId));
+        const all = new Collection();
+        for (const data of list)
+            all.set(data.user.id, this._add(data));
+        for (const id of this.cache.keys())
+            if (!all.has(id))
+                this.cache.delete(id);
+        if (userId === undefined)
+            return all;
+        const found = all.get(userId);
+        if (!found)
+            throw new BaffError('UNKNOWN_MEMBER', `User ${userId} is not a member of server ${this.serverId}.`);
+        return found;
+    }
+    kick(user, reason) {
+        return this.client.rest.delete(Routes.serverMember(this.serverId, this.resolveId(user)), { body: reason ? { reason } : undefined });
+    }
+    ban(user, options = {}) {
+        return this.client.rest.put(Routes.serverBan(this.serverId, this.resolveId(user)), { body: options });
+    }
+    unban(user) {
+        return this.client.rest.delete(Routes.serverBan(this.serverId, this.resolveId(user)));
+    }
+    async fetchBans() {
+        const list = await this.client.rest.get(Routes.serverBans(this.serverId));
+        return new Collection(list.map((b) => [b.user.id, { user: this.client.users._add(b.user), reason: b.reason, createdAt: new Date(b.createdAt) }]));
+    }
+}