qaut.js 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qaut.js",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Official QauT bot framework for building bots and integrations.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -1,136 +1,132 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 
-export declare const Events: {
-  readonly ClientReady: 'clientReady';
-  readonly Debug: 'debug';
-  readonly Error: 'error';
-  readonly MessageCreate: 'messageCreate';
-  readonly MessageUpdate: 'messageUpdate';
-  readonly MessageDelete: 'messageDelete';
-  readonly InteractionCreate: 'interactionCreate';
-  readonly GuildCreate: 'guildCreate';
-  readonly GuildUpdate: 'guildUpdate';
-  readonly GuildDelete: 'guildDelete';
-  readonly GuildMemberAdd: 'guildMemberAdd';
-  readonly GuildMemberRemove: 'guildMemberRemove';
-  readonly PresenceUpdate: 'presenceUpdate';
-  readonly WebhookEvent: 'webhookEvent';
-};
-
+export declare const DefaultRestBase: string;
+export declare const Events: Record<string, string>;
 export declare const GatewayIntentBits: Record<string, number>;
+export declare const Partials: Record<string, string>;
 export declare const Status: Record<string, string>;
 export declare const ActivityType: Record<string, number>;
 export declare const PermissionFlagsBits: Record<string, bigint>;
-export declare const DefaultRestBase = "https://qaut.gg/api";
 
-export declare class QauTError extends Error {
-  details?: unknown;
+export declare class QauTError extends Error { details?: unknown; }
+export declare class Collection<K = string, V = any> extends Map<K, V> {
+  find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+  filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
+  map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+  reduce<T>(fn: (acc: T, value: V, key: K, collection: this) => T, initial: T): T;
+  sort(fn: (a: V, b: V, aKey: K, bKey: K) => number): Collection<K, V>;
+  some(fn: (value: V, key: K, collection: this) => boolean): boolean;
+  every(fn: (value: V, key: K, collection: this) => boolean): boolean;
+  concat(...collections: Collection<K, V>[]): Collection<K, V>;
+  merge(other: Collection<K, V>, whenInSelf?: Function, whenInOther?: Function, whenInBoth?: Function): Collection<K, V>;
+  sweep(fn: (value: V, key: K, collection: this) => boolean): number;
+  random(): V | undefined;
+  randomKey(): K | undefined;
+  first(amount?: number): V | V[] | undefined;
+  firstKey(amount?: number): K | K[] | undefined;
+  last(amount?: number): V | V[] | undefined;
+  lastKey(amount?: number): K | K[] | undefined;
+  at(index: number): V | undefined;
+  clone(): Collection<K, V>;
+  reverse(): Collection<K, V>;
+  partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>];
 }
 
 export declare class BitField {
   bitfield: bigint;
   constructor(bits?: bigint | number | string | Array<bigint | number | string>);
   has(bit: bigint | number | string): boolean;
-  add(...bits: Array<bigint | number | string | Array<bigint | number | string>>): this;
-  remove(...bits: Array<bigint | number | string | Array<bigint | number | string>>): this;
+  add(...bits: any[]): this;
+  remove(...bits: any[]): this;
   toString(): string;
   valueOf(): bigint;
 }
+export declare class PermissionsBitField extends BitField { static Flags: typeof PermissionFlagsBits; }
+export declare class PermissionBitField extends PermissionsBitField {}
+export declare class IntentBitField extends BitField { static Flags: typeof GatewayIntentBits; }
 
-export declare class PermissionBitField extends BitField {}
-export declare class IntentBitField extends BitField {}
-
-export declare class EmbedBuilder {
-  constructor(data?: Record<string, unknown>);
-  setTitle(title: string): this;
-  setDescription(description: string): this;
-  setColor(color: string | number): this;
-  setURL(url: string): this;
-  setTimestamp(timestamp?: Date | string | number): this;
-  setAuthor(author: string | Record<string, unknown>): this;
-  setFooter(footer: string | Record<string, unknown>): this;
-  setImage(url: string): this;
-  setThumbnail(url: string): this;
-  addFields(...fields: Array<{ name: string; value: string; inline?: boolean } | Array<{ name: string; value: string; inline?: boolean }>>): this;
-  toJSON(): Record<string, unknown>;
+declare class Builder<T = any> {
+  data: T;
+  constructor(data?: Partial<T>);
+  toJSON(): T;
 }
-
-export declare class ButtonBuilder {
-  constructor(data?: Record<string, unknown>);
-  setCustomId(customId: string): this;
-  setLabel(label: string): this;
-  setStyle(style: string): this;
-  setURL(url: string): this;
-  setDisabled(disabled?: boolean): this;
-  toJSON(): Record<string, unknown>;
+export declare class EmbedBuilder extends Builder {
+  setTitle(v: string): this; setDescription(v: string): this; setURL(v: string): this; setColor(v: string | number): this;
+  setAuthor(v: string | object): this; setFooter(v: string | object): this; setThumbnail(v: string): this; setImage(v: string): this;
+  setTimestamp(v?: string | number | Date): this; setFields(...fields: any[]): this; addFields(...fields: any[]): this;
 }
-
-export declare class ActionRowBuilder {
-  constructor(data?: { components?: unknown[] });
-  addComponents(...components: unknown[]): this;
-  toJSON(): Record<string, unknown>;
-}
-
-export declare class SlashCommandBuilder {
-  constructor(data?: Record<string, unknown>);
-  setName(name: string): this;
-  setDescription(description: string): this;
-  addStringOption(option: Record<string, unknown>): this;
-  addIntegerOption(option: Record<string, unknown>): this;
-  addBooleanOption(option: Record<string, unknown>): this;
-  toJSON(): Record<string, unknown>;
+export declare class ButtonBuilder extends Builder { setCustomId(v: string): this; setLabel(v: string): this; setStyle(v: string): this; setEmoji(v: any): this; setURL(v: string): this; setDisabled(v?: boolean): this; }
+export declare class ActionRowBuilder extends Builder { addComponents(...components: any[]): this; setComponents(...components: any[]): this; }
+export declare class SelectMenuBuilder extends Builder { setCustomId(v: string): this; setPlaceholder(v: string): this; addOptions(...options: any[]): this; setMinValues(v: number): this; setMaxValues(v: number): this; setDisabled(v?: boolean): this; }
+export declare class StringSelectMenuBuilder extends SelectMenuBuilder {}
+export declare class UserSelectMenuBuilder extends SelectMenuBuilder {}
+export declare class RoleSelectMenuBuilder extends SelectMenuBuilder {}
+export declare class MentionableSelectMenuBuilder extends SelectMenuBuilder {}
+export declare class ChannelSelectMenuBuilder extends SelectMenuBuilder {}
+export declare class ModalBuilder extends Builder { setCustomId(v: string): this; setTitle(v: string): this; addComponents(...components: any[]): this; }
+export declare class TextInputBuilder extends Builder { setCustomId(v: string): this; setLabel(v: string): this; setStyle(v: string): this; setPlaceholder(v: string): this; setRequired(v?: boolean): this; setMinLength(v: number): this; setMaxLength(v: number): this; setValue(v: string): this; }
+export declare class SlashCommandBuilder extends Builder {
+  setName(v: string): this; setDescription(v: string): this; setDefaultMemberPermissions(v: any): this; setDMPermission(v: boolean): this;
+  addStringOption(o: any): this; addIntegerOption(o: any): this; addBooleanOption(o: any): this; addUserOption(o: any): this;
+  addRoleOption(o: any): this; addMentionableOption(o: any): this; addNumberOption(o: any): this; addChannelOption(o: any): this;
+  addAttachmentOption(o: any): this; addSubcommand(o: any): this; addSubcommandGroup(o: any): this;
 }
+export declare class ContextMenuCommandBuilder extends Builder { setName(v: string): this; setType(v: any): this; setDefaultMemberPermissions(v: any): this; setDMPermission(v: boolean): this; }
+export declare const StringOption: typeof SlashCommandBuilder;
+export declare const IntegerOption: typeof SlashCommandBuilder;
+export declare const BooleanOption: typeof SlashCommandBuilder;
+export declare const UserOption: typeof SlashCommandBuilder;
+export declare const RoleOption: typeof SlashCommandBuilder;
+export declare const MentionableOption: typeof SlashCommandBuilder;
+export declare const NumberOption: typeof SlashCommandBuilder;
+export declare const ChannelOption: typeof SlashCommandBuilder;
+export declare const AttachmentOption: typeof SlashCommandBuilder;
+export declare class AttachmentBuilder extends Builder { setFile(v: any): this; setName(v: string): this; setDescription(v: string): this; setSpoiler(v?: boolean): this; }
 
 export declare class REST {
   constructor(options?: { token?: string; baseUrl?: string; authPrefix?: string });
   setToken(token: string): this;
-  request(method: string, route: string, body?: unknown): Promise<unknown>;
-  get(route: string): Promise<unknown>;
-  post(route: string, body?: unknown): Promise<unknown>;
-  patch(route: string, body?: unknown): Promise<unknown>;
-  delete(route: string, body?: unknown): Promise<unknown>;
+  request(method: string, route: string, body?: any): Promise<any>;
+  get(route: string): Promise<any>; post(route: string, body?: any): Promise<any>; put(route: string, body?: any): Promise<any>;
+  patch(route: string, body?: any): Promise<any>; delete(route: string, body?: any): Promise<any>;
 }
 
-export declare class TextChannel {
-  id: string;
-  constructor(client: Client, data?: Record<string, unknown>);
-  send(payload: string | Record<string, unknown>): Promise<unknown>;
-}
-
-export declare class User {
-  id: string;
-  constructor(client: Client, data?: Record<string, unknown>);
-  send(payload: string | Record<string, unknown>): Promise<unknown>;
-}
-
-export declare class Message {
+declare class Entity {
   client: Client;
-  channel: TextChannel | null;
-  author: User | null;
-  content?: string;
-  constructor(client: Client, data?: Record<string, unknown>);
-  reply(payload: string | Record<string, unknown>): Promise<unknown>;
+  id: string;
+  [key: string]: any;
+  constructor(client: Client, data?: any);
 }
+export declare class Guild extends Entity { [key: string]: any; }
+export declare class Channel extends Entity { [key: string]: any; send(payload: any): Promise<any>; }
+export declare class TextChannel extends Channel {}
+export declare class Message extends Entity { [key: string]: any; reply(payload: any): Promise<any>; }
+export declare class User extends Entity { [key: string]: any; send(payload: any): Promise<any>; }
+export declare class GuildMember extends Entity { [key: string]: any; }
+export declare class Role extends Entity { [key: string]: any; }
+export declare class Interaction extends Entity { [key: string]: any; }
+export declare class Reaction extends Entity { [key: string]: any; }
+export declare class Invite extends Entity { [key: string]: any; }
+export declare class Webhook extends Entity { [key: string]: any; }
+export declare class Thread extends Channel { [key: string]: any; }
+export declare class Sticker extends Entity { [key: string]: any; }
+export declare class Emoji extends Entity { [key: string]: any; }
+export declare class ScheduledEvent extends Entity { [key: string]: any; }
+export declare class Collector extends EventEmitter { collected: Collection; next: Promise<any>; stop(reason?: string): void; resetTimer(): this; }
 
 export declare class Client extends EventEmitter {
-  token: string;
-  rest: REST;
-  user: unknown;
-  intents: IntentBitField;
-  polling: boolean;
-  pollIntervalMs: number;
-  keepAlive: boolean;
-  constructor(options?: { token?: string; intents?: Array<number | bigint | string> | number | bigint | string; restBaseUrl?: string; keepAlive?: boolean; polling?: boolean; pollIntervalMs?: number });
-  login(token?: string): Promise<string>;
-  startKeepAlive(): this;
-  startPolling(): this;
-  destroy(): this;
-  setPresence(presence?: Record<string, unknown>): Promise<unknown>;
-  setStatus(status: string): Promise<unknown>;
-  channel(id: string): TextChannel;
-  user(id: string): User;
-  emitGatewayEvent(eventName: string, payload: unknown): boolean;
+  token: string; rest: REST; user: any; guilds: Collection; channels: Collection; users: Collection;
+  constructor(options?: { token?: string; intents?: any; restBaseUrl?: string; keepAlive?: boolean; polling?: boolean; pollIntervalMs?: number; registerProcessShutdown?: boolean });
+  login(token?: string): Promise<string>; destroy(options?: { setOffline?: boolean }): Promise<this>; isReady(): boolean;
+  generateInvite(options?: any): string; fetchInvite(code: string): Promise<any>; fetchWebhook(id: string): Promise<any>; fetchGuildPreview(id: string): Promise<any>;
+  fetchSticker(id: string): Promise<any>; fetchVoiceRegions(): Promise<any>; fetchPremiumStickerPacks(): Promise<any>; fetchApplicationEmojis(): Promise<any>;
+  fetchGuildTemplate(code: string): Promise<any>; fetchStageInstance(id: string): Promise<any>; fetchGuildWidget(id: string): Promise<any>;
+  fetchGuildWidgetImage(id: string): string; fetchGuildWidgetSettings(id: string): Promise<any>; setPresence(presence?: any): Promise<any>; setStatus(status: string): Promise<any>;
+  channel(id: string): Channel; guild(id: string): Guild; user(id: string): User;
 }
 
-export declare function CreateEmbed(data?: Record<string, unknown>): EmbedBuilder;
+export declare function CreateEmbed(data?: any): EmbedBuilder;
+export declare function joinVoiceChannel(options?: any): any; export declare function createAudioPlayer(): any; export declare function createAudioResource(input: any, options?: any): any; export declare function createAudioReceiver(): any; export declare function entersState(target: any): Promise<any>; export declare function getVoiceConnection(): any;
+export declare function time(date?: any, style?: string): string; export declare function userMention(id: any): string; export declare function roleMention(id: any): string; export declare function channelMention(id: any): string; export declare function chatInputApplicationCommandMention(name: string, id: string): string;
+export declare function inlineCode(v: any): string; export declare function codeBlock(lang: string, code?: string): string; export declare function bold(v: any): string; export declare function italic(v: any): string; export declare function underline(v: any): string; export declare function strikethrough(v: any): string; export declare function spoiler(v: any): string; export declare function quoteBlock(v: any): string; export declare function blockQuote(v: any): string; export declare function escapeMarkdown(v: any): string; export declare function hideLinkEmbed(url: string): string; export declare function hyperlink(text: string, url: string): string;

package/src/index.js

@@ -5,8 +5,10 @@ const { EventEmitter } = require('events');
 const DefaultRestBase = 'https://qaut.gg/api';
 
 const Events = Object.freeze({
-  ClientReady: 'clientReady',
+  ClientReady: 'ready',
+  Ready: 'ready',
   Debug: 'debug',
+  Warn: 'warn',
   Error: 'error',
   MessageCreate: 'messageCreate',
   MessageUpdate: 'messageUpdate',
@@ -17,7 +19,29 @@ const Events = Object.freeze({
   GuildDelete: 'guildDelete',
   GuildMemberAdd: 'guildMemberAdd',
   GuildMemberRemove: 'guildMemberRemove',
+  GuildBanAdd: 'guildBanAdd',
+  GuildBanRemove: 'guildBanRemove',
+  VoiceStateUpdate: 'voiceStateUpdate',
   PresenceUpdate: 'presenceUpdate',
+  TypingStart: 'typingStart',
+  ChannelCreate: 'channelCreate',
+  ChannelDelete: 'channelDelete',
+  ChannelUpdate: 'channelUpdate',
+  RoleCreate: 'roleCreate',
+  RoleDelete: 'roleDelete',
+  RoleUpdate: 'roleUpdate',
+  EmojiCreate: 'emojiCreate',
+  EmojiDelete: 'emojiDelete',
+  EmojiUpdate: 'emojiUpdate',
+  StickerCreate: 'stickerCreate',
+  StickerDelete: 'stickerDelete',
+  StickerUpdate: 'stickerUpdate',
+  ThreadCreate: 'threadCreate',
+  ThreadDelete: 'threadDelete',
+  ThreadUpdate: 'threadUpdate',
+  InviteCreate: 'inviteCreate',
+  InviteDelete: 'inviteDelete',
+  WebhooksUpdate: 'webhooksUpdate',
   WebhookEvent: 'webhookEvent'
 });
 
@@ -27,8 +51,23 @@ const GatewayIntentBits = Object.freeze({
   GuildMessages: 1 << 2,
   MessageContent: 1 << 3,
   GuildPresences: 1 << 4,
-  DirectMessages: 1 << 5,
-  Webhooks: 1 << 6
+  GuildVoiceStates: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildWebhooks: 1 << 7,
+  GuildEmojisAndStickers: 1 << 8,
+  DirectMessages: 1 << 9,
+  DirectMessageTyping: 1 << 10,
+  DirectMessageReactions: 1 << 11,
+  Webhooks: 1 << 7
+});
+
+const Partials = Object.freeze({
+  User: 'USER',
+  Channel: 'CHANNEL',
+  GuildMember: 'GUILD_MEMBER',
+  Message: 'MESSAGE',
+  Reaction: 'REACTION',
+  ThreadMember: 'THREAD_MEMBER'
 });
 
 const Status = Object.freeze({
@@ -39,18 +78,12 @@ const Status = Object.freeze({
   Offline: 'offline'
 });
 
-const ActivityType = Object.freeze({
-  Playing: 0,
-  Streaming: 1,
-  Listening: 2,
-  Watching: 3,
-  Custom: 4,
-  Competing: 5
-});
+const ActivityType = Object.freeze({ Playing: 0, Streaming: 1, Listening: 2, Watching: 3, Custom: 4, Competing: 5 });
 
 const PermissionFlagsBits = Object.freeze({
   Administrator: 1n << 0n,
   ViewAuditLog: 1n << 1n,
+  ManageGuild: 1n << 2n,
   ManageServer: 1n << 2n,
   ManageRoles: 1n << 3n,
   ManageChannels: 1n << 4n,
@@ -58,7 +91,9 @@ const PermissionFlagsBits = Object.freeze({
   BanMembers: 1n << 6n,
   CreateInstantInvite: 1n << 7n,
   ManageWebhooks: 1n << 11n,
+  ViewChannel: 1n << 12n,
   ViewChannels: 1n << 12n,
+  ModerateMembers: 1n << 14n,
   SendMessages: 1n << 20n,
   ManageMessages: 1n << 24n,
   EmbedLinks: 1n << 25n,
@@ -83,168 +118,338 @@ class QauTError extends Error {
   }
 }
 
-class BitField {
-  constructor(bits = 0n) {
-    this.bitfield = Array.isArray(bits) ? bits.reduce((total, bit) => total | BigInt(bit), 0n) : BigInt(bits);
-  }
-
-  has(bit) {
-    return (this.bitfield & BigInt(bit)) === BigInt(bit);
-  }
-
-  add(...bits) {
-    bits.flat().forEach(bit => { this.bitfield |= BigInt(bit); });
-    return this;
-  }
-
-  remove(...bits) {
-    bits.flat().forEach(bit => { this.bitfield &= ~BigInt(bit); });
-    return this;
-  }
-
-  toString() {
-    return this.bitfield.toString();
-  }
-
-  valueOf() {
-    return this.bitfield;
+class Collection extends Map {
+  find(fn) { for (const item of this.values()) if (fn(item, item?.id, this)) return item; return undefined; }
+  filter(fn) { const out = new Collection(); for (const [k, v] of this) if (fn(v, k, this)) out.set(k, v); return out; }
+  map(fn) { return [...this].map(([k, v]) => fn(v, k, this)); }
+  reduce(fn, initial) { let acc = initial; for (const [k, v] of this) acc = fn(acc, v, k, this); return acc; }
+  sort(fn) { return new Collection([...this].sort((a, b) => fn(a[1], b[1], a[0], b[0]))); }
+  some(fn) { for (const [k, v] of this) if (fn(v, k, this)) return true; return false; }
+  every(fn) { for (const [k, v] of this) if (!fn(v, k, this)) return false; return true; }
+  concat(...cols) { const out = this.clone(); cols.forEach(col => [...col].forEach(([k, v]) => out.set(k, v))); return out; }
+  merge(other, whenInSelf = (_old, val) => val, whenInOther = val => val, whenInBoth = (_old, val) => val) {
+    const out = new Collection();
+    for (const [k, v] of this) out.set(k, other.has(k) ? whenInBoth(v, other.get(k), k) : whenInSelf(v, k));
+    for (const [k, v] of other) if (!this.has(k)) out.set(k, whenInOther(v, k));
+    return out;
   }
+  sweep(fn) { let count = 0; for (const [k, v] of this) if (fn(v, k, this)) { this.delete(k); count++; } return count; }
+  random() { const arr = [...this.values()]; return arr[Math.floor(Math.random() * arr.length)]; }
+  randomKey() { const arr = [...this.keys()]; return arr[Math.floor(Math.random() * arr.length)]; }
+  first(amount) { const arr = [...this.values()]; return amount ? arr.slice(0, amount) : arr[0]; }
+  firstKey(amount) { const arr = [...this.keys()]; return amount ? arr.slice(0, amount) : arr[0]; }
+  last(amount) { const arr = [...this.values()]; return amount ? arr.slice(-amount) : arr[arr.length - 1]; }
+  lastKey(amount) { const arr = [...this.keys()]; return amount ? arr.slice(-amount) : arr[arr.length - 1]; }
+  at(index) { return [...this.values()].at(index); }
+  clone() { return new Collection(this); }
+  reverse() { return new Collection([...this].reverse()); }
+  partition(fn) { const yes = new Collection(); const no = new Collection(); for (const [k, v] of this) (fn(v, k, this) ? yes : no).set(k, v); return [yes, no]; }
 }
 
-class PermissionBitField extends BitField {
-  static Flags = PermissionFlagsBits;
+class BitField {
+  constructor(bits = 0n) { this.bitfield = Array.isArray(bits) ? bits.reduce((t, b) => t | BigInt(b), 0n) : BigInt(bits); }
+  has(bit) { return (this.bitfield & BigInt(bit)) === BigInt(bit); }
+  add(...bits) { bits.flat().forEach(bit => { this.bitfield |= BigInt(bit); }); return this; }
+  remove(...bits) { bits.flat().forEach(bit => { this.bitfield &= ~BigInt(bit); }); return this; }
+  toString() { return this.bitfield.toString(); }
+  valueOf() { return this.bitfield; }
 }
+class PermissionsBitField extends BitField { static Flags = PermissionFlagsBits; }
+class PermissionBitField extends PermissionsBitField {}
+class IntentBitField extends BitField { static Flags = GatewayIntentBits; }
 
-class IntentBitField extends BitField {
-  static Flags = GatewayIntentBits;
+class DataBuilder {
+  constructor(data = {}) { this.data = { ...data }; }
+  toJSON() { return structuredCloneSafe(this.data); }
 }
 
-class EmbedBuilder {
-  constructor(data = {}) {
-    this.data = { ...data };
-  }
-
-  setTitle(title) { this.data.title = String(title).slice(0, 256); return this; }
-  setDescription(description) { this.data.description = String(description).slice(0, 4096); return this; }
-  setColor(color) { this.data.color = normalizeColor(color); return this; }
-  setURL(url) { this.data.url = String(url); return this; }
-  setTimestamp(timestamp = new Date()) { this.data.timestamp = new Date(timestamp).toISOString(); return this; }
-  setAuthor(author) { this.data.author = typeof author === 'string' ? { name: author } : { ...author }; return this; }
-  setFooter(footer) { this.data.footer = typeof footer === 'string' ? { text: footer } : { ...footer }; return this; }
-  setImage(url) { this.data.image = { url: String(url) }; return this; }
-  setThumbnail(url) { this.data.thumbnail = { url: String(url) }; return this; }
-
-  addFields(...fields) {
-    this.data.fields ||= [];
-    this.data.fields.push(...fields.flat().map(field => ({
-      name: String(field.name).slice(0, 256),
-      value: String(field.value).slice(0, 1024),
-      inline: Boolean(field.inline)
-    })));
-    this.data.fields = this.data.fields.slice(0, 25);
-    return this;
-  }
+class EmbedBuilder extends DataBuilder {
+  setTitle(v) { this.data.title = String(v).slice(0, 256); return this; }
+  setDescription(v) { this.data.description = String(v).slice(0, 4096); return this; }
+  setURL(v) { this.data.url = String(v); return this; }
+  setColor(v) { this.data.color = normalizeColor(v); return this; }
+  setAuthor(v) { this.data.author = typeof v === 'string' ? { name: v } : { ...v }; return this; }
+  setFooter(v) { this.data.footer = typeof v === 'string' ? { text: v } : { ...v }; return this; }
+  setThumbnail(v) { this.data.thumbnail = { url: String(v) }; return this; }
+  setImage(v) { this.data.image = { url: String(v) }; return this; }
+  setTimestamp(v = new Date()) { this.data.timestamp = new Date(v).toISOString(); return this; }
+  setFields(...fields) { this.data.fields = []; return this.addFields(...fields); }
+  addFields(...fields) { this.data.fields ||= []; this.data.fields.push(...fields.flat().map(normalizeField)); this.data.fields = this.data.fields.slice(0, 25); return this; }
+}
 
-  toJSON() {
-    return { ...this.data };
-  }
+class ButtonBuilder extends DataBuilder {
+  constructor(data = {}) { super({ type: 'button', style: 'primary', ...data }); }
+  setCustomId(v) { this.data.custom_id = String(v); return this; }
+  setLabel(v) { this.data.label = String(v).slice(0, 80); return this; }
+  setStyle(v) { this.data.style = v; return this; }
+  setEmoji(v) { this.data.emoji = v; return this; }
+  setURL(v) { this.data.url = String(v); this.data.style = 'link'; return this; }
+  setDisabled(v = true) { this.data.disabled = Boolean(v); return this; }
 }
 
-class ButtonBuilder {
-  constructor(data = {}) { this.data = { type: 'button', style: 'primary', ...data }; }
-  setCustomId(customId) { this.data.custom_id = String(customId); return this; }
-  setLabel(label) { this.data.label = String(label).slice(0, 80); return this; }
-  setStyle(style) { this.data.style = style; return this; }
-  setURL(url) { this.data.url = String(url); this.data.style = 'link'; return this; }
-  setDisabled(disabled = true) { this.data.disabled = Boolean(disabled); return this; }
-  toJSON() { return { ...this.data }; }
+class ActionRowBuilder extends DataBuilder {
+  constructor(data = {}) { super({ type: 'action_row', components: data.components || [] }); }
+  addComponents(...components) { this.data.components.push(...components.flat()); return this; }
+  setComponents(...components) { this.data.components = components.flat(); return this; }
+  toJSON() { return { ...this.data, components: this.data.components.map(toJSON) }; }
 }
 
-class ActionRowBuilder {
-  constructor(data = {}) { this.components = data.components || []; }
-  addComponents(...components) { this.components.push(...components.flat()); return this; }
-  toJSON() { return { type: 'action_row', components: this.components.map(component => toJSON(component)) }; }
+class SelectMenuBuilder extends DataBuilder {
+  constructor(type = 'string_select', data = {}) { super({ type, options: [], ...data }); }
+  setCustomId(v) { this.data.custom_id = String(v); return this; }
+  setPlaceholder(v) { this.data.placeholder = String(v); return this; }
+  addOptions(...options) { this.data.options ||= []; this.data.options.push(...options.flat()); return this; }
+  setMinValues(v) { this.data.min_values = Number(v); return this; }
+  setMaxValues(v) { this.data.max_values = Number(v); return this; }
+  setDisabled(v = true) { this.data.disabled = Boolean(v); return this; }
+}
+class StringSelectMenuBuilder extends SelectMenuBuilder { constructor(data) { super('string_select', data); } }
+class UserSelectMenuBuilder extends SelectMenuBuilder { constructor(data) { super('user_select', data); } }
+class RoleSelectMenuBuilder extends SelectMenuBuilder { constructor(data) { super('role_select', data); } }
+class MentionableSelectMenuBuilder extends SelectMenuBuilder { constructor(data) { super('mentionable_select', data); } }
+class ChannelSelectMenuBuilder extends SelectMenuBuilder { constructor(data) { super('channel_select', data); } }
+
+class ModalBuilder extends DataBuilder {
+  constructor(data = {}) { super({ components: [], ...data }); }
+  setCustomId(v) { this.data.custom_id = String(v); return this; }
+  setTitle(v) { this.data.title = String(v).slice(0, 45); return this; }
+  addComponents(...components) { this.data.components.push(...components.flat()); return this; }
 }
 
-class SlashCommandBuilder {
-  constructor(data = {}) {
-    this.data = { type: 'chat_input', options: [], ...data };
-  }
+class TextInputBuilder extends DataBuilder {
+  constructor(data = {}) { super({ type: 'text_input', ...data }); }
+  setCustomId(v) { this.data.custom_id = String(v); return this; }
+  setLabel(v) { this.data.label = String(v); return this; }
+  setStyle(v) { this.data.style = v; return this; }
+  setPlaceholder(v) { this.data.placeholder = String(v); return this; }
+  setRequired(v = true) { this.data.required = Boolean(v); return this; }
+  setMinLength(v) { this.data.min_length = Number(v); return this; }
+  setMaxLength(v) { this.data.max_length = Number(v); return this; }
+  setValue(v) { this.data.value = String(v); return this; }
+}
 
-  setName(name) { this.data.name = String(name).toLowerCase().replace(/\s+/g, '-').slice(0, 32); return this; }
-  setDescription(description) { this.data.description = String(description).slice(0, 100); return this; }
-  addStringOption(option) { this.data.options.push({ type: 'string', ...option }); return this; }
-  addIntegerOption(option) { this.data.options.push({ type: 'integer', ...option }); return this; }
-  addBooleanOption(option) { this.data.options.push({ type: 'boolean', ...option }); return this; }
-  toJSON() { return { ...this.data, options: [...this.data.options] }; }
+class SlashCommandBuilder extends DataBuilder {
+  constructor(data = {}) { super({ type: 'chat_input', options: [], ...data }); }
+  setName(v) { this.data.name = String(v).toLowerCase().replace(/\s+/g, '-').slice(0, 32); return this; }
+  setDescription(v) { this.data.description = String(v).slice(0, 100); return this; }
+  setDefaultMemberPermissions(v) { this.data.default_member_permissions = v?.toString?.() || String(v); return this; }
+  setDMPermission(v) { this.data.dm_permission = Boolean(v); return this; }
+  addStringOption(o) { return this.addOption('string', o); }
+  addIntegerOption(o) { return this.addOption('integer', o); }
+  addBooleanOption(o) { return this.addOption('boolean', o); }
+  addUserOption(o) { return this.addOption('user', o); }
+  addRoleOption(o) { return this.addOption('role', o); }
+  addMentionableOption(o) { return this.addOption('mentionable', o); }
+  addNumberOption(o) { return this.addOption('number', o); }
+  addChannelOption(o) { return this.addOption('channel', o); }
+  addAttachmentOption(o) { return this.addOption('attachment', o); }
+  addSubcommand(o) { return this.addOption('subcommand', o); }
+  addSubcommandGroup(o) { return this.addOption('subcommand_group', o); }
+  addOption(type, option) { this.data.options.push(normalizeOption(type, option)); return this; }
+}
+class ContextMenuCommandBuilder extends DataBuilder {
+  setName(v) { this.data.name = String(v); return this; }
+  setType(v) { this.data.type = v; return this; }
+  setDefaultMemberPermissions(v) { this.data.default_member_permissions = v?.toString?.() || String(v); return this; }
+  setDMPermission(v) { this.data.dm_permission = Boolean(v); return this; }
+}
+const StringOption = SlashCommandBuilder;
+const IntegerOption = SlashCommandBuilder;
+const BooleanOption = SlashCommandBuilder;
+const UserOption = SlashCommandBuilder;
+const RoleOption = SlashCommandBuilder;
+const MentionableOption = SlashCommandBuilder;
+const NumberOption = SlashCommandBuilder;
+const ChannelOption = SlashCommandBuilder;
+const AttachmentOption = SlashCommandBuilder;
+
+class AttachmentBuilder extends DataBuilder {
+  setFile(v) { this.data.file = v; return this; }
+  setName(v) { this.data.name = String(v); return this; }
+  setDescription(v) { this.data.description = String(v); return this; }
+  setSpoiler(v = true) { this.data.spoiler = Boolean(v); return this; }
 }
 
 class REST {
-  constructor(options = {}) {
-    this.baseUrl = String(options.baseUrl || DefaultRestBase).replace(/\/+$/, '');
-    this.token = options.token || '';
-    this.authPrefix = options.authPrefix || 'Bot';
-  }
-
-  setToken(token) {
-    this.token = token;
-    return this;
-  }
-
+  constructor(options = {}) { this.baseUrl = String(options.baseUrl || DefaultRestBase).replace(/\/+$/, ''); this.token = options.token || ''; this.authPrefix = options.authPrefix || 'Bot'; }
+  setToken(token) { this.token = token; return this; }
   async request(method, route, body) {
     const response = await fetch(`${this.baseUrl}${route}`, {
       method,
-      headers: {
-        Authorization: `${this.authPrefix} ${this.token}`,
-        'Content-Type': 'application/json'
-      },
+      headers: { Authorization: `${this.authPrefix} ${this.token}`, 'Content-Type': 'application/json' },
       body: body === undefined ? undefined : JSON.stringify(serialize(body))
     });
     const data = await response.json().catch(() => null);
     if (!response.ok) throw new QauTError(data?.error || response.statusText, { status: response.status, data });
     return data;
   }
-
   get(route) { return this.request('GET', route); }
   post(route, body) { return this.request('POST', route, body); }
+  put(route, body) { return this.request('PUT', route, body); }
   patch(route, body) { return this.request('PATCH', route, body); }
   delete(route, body) { return this.request('DELETE', route, body); }
 }
 
-class TextChannel {
-  constructor(client, data = {}) {
-    this.client = client;
-    Object.assign(this, data);
-  }
+class Base {
+  constructor(client, data = {}) { this.client = client; Object.assign(this, data); }
+  notImplemented(name) { throw new QauTError(`${name} is not implemented by the QauT API yet`, { code: 'NOT_IMPLEMENTED' }); }
+}
 
-  send(payload) {
-    return this.client.rest.post(`/bot/channels/${this.id}/messages`, normalizeMessagePayload(payload));
-  }
+class Guild extends Base {
+  fetch() { return this.client.rest.get(`/bot/guilds/${this.id}`); }
+  leave() { return this.client.rest.delete(`/bot/guilds/${this.id}/members/@me`); }
+  delete() { return this.client.rest.delete(`/bot/guilds/${this.id}`); }
+  edit(data) { return this.client.rest.patch(`/bot/guilds/${this.id}`, data); }
+  setName(v) { return this.edit({ name: v }); }
+  setIcon(v) { return this.edit({ icon: v }); }
+  setBanner(v) { return this.edit({ banner: v }); }
+  setSplash(v) { return this.edit({ splash: v }); }
+  setDescription(v) { return this.edit({ description: v }); }
+  setVerificationLevel(v) { return this.edit({ verificationLevel: v }); }
+  setExplicitContentFilter(v) { return this.edit({ explicitContentFilter: v }); }
+  setDefaultMessageNotifications(v) { return this.edit({ defaultNotifications: v }); }
+  setAFKChannel(v) { return this.edit({ afkChannelId: idOf(v) }); }
+  setAFKTimeout(v) { return this.edit({ afkTimeout: v }); }
+  setOwner(v) { return this.edit({ ownerId: idOf(v) }); }
+  fetchAuditLogs() { return this.client.rest.get(`/bot/guilds/${this.id}/audit-logs`); }
+  fetchOwner() { return this.client.rest.get(`/bot/guilds/${this.id}/owner`); }
+  fetchPreview() { return this.client.fetchGuildPreview(this.id); }
+  fetchTemplates() { return this.client.rest.get(`/bot/guilds/${this.id}/templates`); }
+  fetchVanityData() { return this.client.rest.get(`/bot/guilds/${this.id}/vanity`); }
+  fetchWebhooks() { return this.client.rest.get(`/bot/guilds/${this.id}/webhooks`); }
+  fetchIntegrations() { return this.client.rest.get(`/bot/guilds/${this.id}/integrations`); }
+  fetchInvites() { return this.client.rest.get(`/bot/guilds/${this.id}/invites`); }
+  fetchWidget() { return this.client.fetchGuildWidget(this.id); }
+  fetchWidgetSettings() { return this.client.fetchGuildWidgetSettings(this.id); }
+  setWidgetSettings(data) { return this.client.rest.patch(`/bot/guilds/${this.id}/widget`, data); }
+  createEmoji(data) { return this.client.rest.post(`/bot/guilds/${this.id}/emojis`, data); }
+  createSticker(data) { return this.client.rest.post(`/bot/guilds/${this.id}/stickers`, data); }
+  createTemplate(data) { return this.client.rest.post(`/bot/guilds/${this.id}/templates`, data); }
+  createChannel(data) { return this.client.rest.post(`/bot/guilds/${this.id}/channels`, data); }
+  createRole(data) { return this.client.rest.post(`/bot/guilds/${this.id}/roles`, data); }
+  createScheduledEvent(data) { return this.client.rest.post(`/bot/guilds/${this.id}/scheduled-events`, data); }
+  get commands() { return commandManager(this.client, `/bot/guilds/${this.id}/commands`); }
 }
 
-class User {
-  constructor(client, data = {}) {
-    this.client = client;
-    Object.assign(this, data);
-  }
+class Channel extends Base {
+  send(payload) { return this.client.rest.post(`/bot/channels/${this.id}/messages`, normalizeMessagePayload(payload)); }
+  sendTyping() { return this.client.rest.post(`/bot/channels/${this.id}/typing`, {}); }
+  fetch() { return this.client.rest.get(`/bot/channels/${this.id}`); }
+  edit(data) { return this.client.rest.patch(`/bot/channels/${this.id}`, data); }
+  delete() { return this.client.rest.delete(`/bot/channels/${this.id}`); }
+  clone(data) { return this.client.rest.post(`/bot/channels/${this.id}/clone`, data || {}); }
+  setName(v) { return this.edit({ name: v }); }
+  setTopic(v) { return this.edit({ topic: v }); }
+  setNSFW(v = true) { return this.edit({ nsfw: Boolean(v) }); }
+  setParent(v) { return this.edit({ parentId: idOf(v) }); }
+  setPosition(v) { return this.edit({ position: v }); }
+  setRateLimitPerUser(v) { return this.edit({ rateLimitPerUser: v }); }
+  setBitrate(v) { return this.edit({ bitrate: v }); }
+  setUserLimit(v) { return this.edit({ userLimit: v }); }
+  setRTCRegion(v) { return this.edit({ rtcRegion: v }); }
+  lockPermissions() { return this.edit({ lockPermissions: true }); }
+  bulkDelete(messages) { return this.client.rest.post(`/bot/channels/${this.id}/messages/bulk-delete`, { messages: idsOf(messages) }); }
+  createWebhook(data) { return this.client.rest.post(`/bot/channels/${this.id}/webhooks`, data); }
+  fetchWebhooks() { return this.client.rest.get(`/bot/channels/${this.id}/webhooks`); }
+  createInvite(data) { return this.client.rest.post(`/bot/channels/${this.id}/invites`, data || {}); }
+  fetchInvites() { return this.client.rest.get(`/bot/channels/${this.id}/invites`); }
+  awaitMessages() { return Promise.resolve(new Collection()); }
+  createMessageCollector(options) { return new Collector(options); }
+  createMessageComponentCollector(options) { return new Collector(options); }
+  get threads() { return { create: data => this.client.rest.post(`/bot/channels/${this.id}/threads`, data) }; }
+  get messages() { return { fetch: id => this.client.rest.get(id ? `/bot/channels/${this.id}/messages/${id}` : `/bot/channels/${this.id}/messages`) }; }
+  get permissionOverwrites() { return permissionOverwriteManager(this.client, `/bot/channels/${this.id}/permissions`); }
+}
+const TextChannel = Channel;
+
+class Message extends Base {
+  constructor(client, data = {}) { super(client, data); this.channel = data.channel || (data.channelId ? new Channel(client, { id: data.channelId }) : null); this.author = data.author ? new User(client, data.author) : null; }
+  reply(payload) { if (!this.channel) throw new QauTError('Cannot reply without channel information'); return this.channel.send(payload); }
+  react(emoji) { return this.client.rest.post(`/bot/messages/${this.id}/reactions`, { emoji }); }
+  delete() { return this.client.rest.delete(`/bot/messages/${this.id}`); }
+  edit(payload) { return this.client.rest.patch(`/bot/messages/${this.id}`, normalizeMessagePayload(payload)); }
+  fetch() { return this.client.rest.get(`/bot/messages/${this.id}`); }
+  pin() { return this.client.rest.put(`/bot/messages/${this.id}/pin`, {}); }
+  unpin() { return this.client.rest.delete(`/bot/messages/${this.id}/pin`); }
+  crosspost() { return this.client.rest.post(`/bot/messages/${this.id}/crosspost`, {}); }
+  forward(channel) { return new Channel(this.client, { id: idOf(channel) }).send({ content: this.content, embeds: this.embeds, attachments: this.attachments }); }
+  startThread(data) { return this.client.rest.post(`/bot/messages/${this.id}/thread`, data || {}); }
+  removeAttachments() { return this.edit({ attachments: [] }); }
+  suppressEmbeds(v = true) { return this.edit({ suppressEmbeds: Boolean(v) }); }
+  createReactionCollector(options) { return new Collector(options); }
+  awaitReactions() { return Promise.resolve(new Collection()); }
+  createMessageComponentCollector(options) { return new Collector(options); }
+  awaitMessageComponent() { return new Promise(resolve => this.createMessageComponentCollector({ max: 1 }).once('collect', resolve)); }
+}
 
-  send(payload) {
-    return this.client.rest.post(`/bot/users/${this.id}/messages`, normalizeMessagePayload(payload));
-  }
+class User extends Base {
+  fetch() { return this.client.rest.get(`/bot/users/${this.id}`); }
+  send(payload) { return this.client.rest.post(`/bot/users/${this.id}/messages`, normalizeMessagePayload(payload)); }
+  createDM() { return this.client.rest.post(`/bot/users/${this.id}/dm`, {}); }
+  displayAvatarURL() { return this.avatarURL(); }
+  avatarURL() { return this.avatar || this.defaultAvatarURL(); }
+  bannerURL() { return this.banner || null; }
+  defaultAvatarURL() { return `${DefaultRestBase.replace('/api', '')}/assets/qautapp.png`; }
+  get displayName() { return this.globalName || this.username || this.id; }
+  fetchFlags() { return Promise.resolve(this.flags || []); }
 }
 
-class Message {
-  constructor(client, data = {}) {
-    this.client = client;
-    Object.assign(this, data);
-    this.channel = data.channel || (data.channelId ? new TextChannel(client, { id: data.channelId }) : null);
-    this.author = data.author ? new User(client, data.author) : null;
-  }
+class GuildMember extends Base {
+  fetch() { return this.client.rest.get(`/bot/guilds/${this.guildId}/members/${this.id}`); }
+  edit(data) { return this.client.rest.patch(`/bot/guilds/${this.guildId}/members/${this.id}`, data); }
+  kick(reason) { return this.client.rest.delete(`/bot/guilds/${this.guildId}/members/${this.id}`, { reason }); }
+  ban(data) { return this.client.rest.post(`/bot/guilds/${this.guildId}/bans`, { userId: this.id, ...data }); }
+  timeout(ms, reason) { return this.disableCommunicationUntil(Date.now() + ms, reason); }
+  disableCommunicationUntil(time, reason) { return this.edit({ communicationDisabledUntil: new Date(time).toISOString(), reason }); }
+  send(payload) { return new User(this.client, { id: this.id }).send(payload); }
+  setNickname(v) { return this.edit({ nickname: v }); }
+  setAvatar(v) { return this.edit({ avatar: v }); }
+  setBanner(v) { return this.edit({ banner: v }); }
+  setCommunicationDisabledUntil(v) { return this.disableCommunicationUntil(v); }
+  get roles() { return roleMemberManager(this.client, this.guildId, this.id); }
+  get voice() { return voiceMemberManager(this.client, this.guildId, this.id); }
+}
 
-  reply(payload) {
-    if (!this.channel) throw new QauTError('Cannot reply without channel information');
-    return this.channel.send(payload);
-  }
+class Role extends Base {
+  edit(data) { return this.client.rest.patch(`/bot/guilds/${this.guildId}/roles/${this.id}`, data); }
+  delete() { return this.client.rest.delete(`/bot/guilds/${this.guildId}/roles/${this.id}`); }
+  setName(v) { return this.edit({ name: v }); }
+  setColor(v) { return this.edit({ color: v }); }
+  setColors(v) { return this.edit({ colors: v }); }
+  setPermissions(v) { return this.edit({ permissions: v?.toString?.() || v }); }
+  setMentionable(v = true) { return this.edit({ mentionable: Boolean(v) }); }
+  setHoist(v = true) { return this.edit({ hoist: Boolean(v) }); }
+  setPosition(v) { return this.edit({ position: v }); }
+  comparePositionTo(role) { return (this.position || 0) - (role.position || 0); }
+}
+
+class Interaction extends Base {
+  reply(payload) { return this.client.rest.post(`/bot/interactions/${this.id}/reply`, normalizeMessagePayload(payload)); }
+  editReply(payload) { return this.client.rest.patch(`/bot/interactions/${this.id}/reply`, normalizeMessagePayload(payload)); }
+  deferReply(data) { return this.client.rest.post(`/bot/interactions/${this.id}/defer`, data || {}); }
+  followUp(payload) { return this.client.rest.post(`/bot/interactions/${this.id}/followups`, normalizeMessagePayload(payload)); }
+  deleteReply() { return this.client.rest.delete(`/bot/interactions/${this.id}/reply`); }
+  fetchReply() { return this.client.rest.get(`/bot/interactions/${this.id}/reply`); }
+  showModal(modal) { return this.client.rest.post(`/bot/interactions/${this.id}/modal`, toJSON(modal)); }
+  awaitModalSubmit() { return Promise.resolve(null); }
+  update(payload) { return this.client.rest.patch(`/bot/interactions/${this.id}/message`, normalizeMessagePayload(payload)); }
+  deferUpdate() { return this.client.rest.post(`/bot/interactions/${this.id}/defer-update`, {}); }
+}
+
+class Reaction extends Base { fetch() { return this.client.rest.get(`/bot/reactions/${this.id}`); } remove() { return this.client.rest.delete(`/bot/reactions/${this.id}`); } get users() { return { fetch: () => this.client.rest.get(`/bot/reactions/${this.id}/users`), remove: id => this.client.rest.delete(`/bot/reactions/${this.id}/users/${id}`) }; } }
+class Invite extends Base { fetch() { return this.client.fetchInvite(this.code || this.id); } delete() { return this.client.rest.delete(`/bot/invites/${this.code || this.id}`); } }
+class Webhook extends Base { send(p) { return this.client.rest.post(`/bot/webhooks/${this.id}`, normalizeMessagePayload(p)); } edit(d) { return this.client.rest.patch(`/bot/webhooks/${this.id}`, d); } delete() { return this.client.rest.delete(`/bot/webhooks/${this.id}`); } fetchMessage(id) { return this.client.rest.get(`/bot/webhooks/${this.id}/messages/${id}`); } editMessage(id, p) { return this.client.rest.patch(`/bot/webhooks/${this.id}/messages/${id}`, normalizeMessagePayload(p)); } deleteMessage(id) { return this.client.rest.delete(`/bot/webhooks/${this.id}/messages/${id}`); } }
+class Thread extends Channel { join() { return this.client.rest.put(`/bot/threads/${this.id}/members/@me`, {}); } leave() { return this.client.rest.delete(`/bot/threads/${this.id}/members/@me`); } setArchived(v = true) { return this.edit({ archived: Boolean(v) }); } setLocked(v = true) { return this.edit({ locked: Boolean(v) }); } setInvitable(v = true) { return this.edit({ invitable: Boolean(v) }); } get members() { return { add: id => this.client.rest.put(`/bot/threads/${this.id}/members/${id}`, {}), remove: id => this.client.rest.delete(`/bot/threads/${this.id}/members/${id}`) }; } }
+class Sticker extends Base { fetch() { return this.client.fetchSticker(this.id); } edit(d) { return this.client.rest.patch(`/bot/stickers/${this.id}`, d); } delete() { return this.client.rest.delete(`/bot/stickers/${this.id}`); } }
+class Emoji extends Base { fetchAuthor() { return this.client.rest.get(`/bot/emojis/${this.id}/author`); } edit(d) { return this.client.rest.patch(`/bot/emojis/${this.id}`, d); } delete() { return this.client.rest.delete(`/bot/emojis/${this.id}`); } }
+class ScheduledEvent extends Base { fetch() { return this.client.rest.get(`/bot/scheduled-events/${this.id}`); } edit(d) { return this.client.rest.patch(`/bot/scheduled-events/${this.id}`, d); } delete() { return this.client.rest.delete(`/bot/scheduled-events/${this.id}`); } setName(v) { return this.edit({ name: v }); } setDescription(v) { return this.edit({ description: v }); } setLocation(v) { return this.edit({ location: v }); } setEntityType(v) { return this.edit({ entityType: v }); } setStatus(v) { return this.edit({ status: v }); } }
+
+class Collector extends EventEmitter {
+  constructor(options = {}) { super(); this.options = options; this.ended = false; this.collected = new Collection(); this.next = new Promise(resolve => this.once('collect', resolve)); }
+  collect(item) { if (this.ended) return; this.collected.set(item.id || Date.now().toString(), item); this.emit('collect', item); }
+  dispose(item) { this.emit('dispose', item); }
+  stop(reason = 'user') { if (this.ended) return; this.ended = true; this.emit('end', this.collected, reason); }
+  resetTimer() { return this; }
 }
 
 class Client extends EventEmitter {
@@ -255,129 +460,99 @@ class Client extends EventEmitter {
     this.intents = new IntentBitField(options.intents || 0);
     this.rest = new REST({ token: this.token, baseUrl: options.restBaseUrl || DefaultRestBase });
     this.user = null;
+    this.guilds = new Collection();
+    this.channels = new Collection();
+    this.users = new Collection();
     this.keepAlive = options.keepAlive !== false;
-    this.keepAliveInterval = null;
     this.polling = options.polling !== false;
     this.pollIntervalMs = Number(options.pollIntervalMs || 1500);
-    this.pollInterval = null;
-    this.gatewayCursor = null;
-  }
-
-  async login(token = this.token) {
-    if (!token) throw new QauTError('Bot token is required');
-    this.token = token;
-    this.rest.setToken(token);
-    const me = await this.rest.get('/bot/me');
-    this.user = me;
-    if (this.keepAlive) this.startKeepAlive();
-    if (this.polling) this.startPolling();
-    this.emit(Events.ClientReady, me);
-    return token;
-  }
-
-  startKeepAlive() {
-    if (this.keepAliveInterval) return this;
-    this.keepAliveInterval = setInterval(() => {
-      this.emit(Events.Debug, 'QauT.js keep-alive heartbeat');
-    }, 30_000);
-    return this;
-  }
-
-  destroy() {
-    if (this.keepAliveInterval) clearInterval(this.keepAliveInterval);
-    if (this.pollInterval) clearInterval(this.pollInterval);
     this.keepAliveInterval = null;
     this.pollInterval = null;
-    this.user = null;
-    return this;
-  }
-
-  startPolling() {
-    if (this.pollInterval) return this;
-    this.gatewayCursor = new Date().toISOString();
-    const tick = async () => {
-      try {
-        const query = this.gatewayCursor ? `?after=${encodeURIComponent(this.gatewayCursor)}` : '';
-        const data = await this.rest.get(`/bot/gateway/messages${query}`);
-        this.gatewayCursor = data.cursor || new Date().toISOString();
-        for (const payload of data.messages || []) {
-          this.emitGatewayEvent(Events.MessageCreate, payload);
-        }
-      } catch (err) {
-        this.emit(Events.Error, err);
-      }
-    };
-    this.pollInterval = setInterval(tick, this.pollIntervalMs);
-    return this;
-  }
-
-  async setPresence(presence = {}) {
-    return this.rest.patch('/bot/presence', presence);
-  }
-
-  async setStatus(status) {
-    return this.setPresence({ status });
-  }
-
-  channel(id) {
-    return new TextChannel(this, { id });
-  }
-
-  user(id) {
-    return new User(this, { id });
-  }
-
-  emitGatewayEvent(eventName, payload) {
-    if (eventName === Events.MessageCreate) return this.emit(eventName, new Message(this, payload));
-    return this.emit(eventName, payload);
+    this.gatewayCursor = null;
+    this.destroyed = false;
+    this.registerProcessShutdown = options.registerProcessShutdown !== false;
+    this.boundShutdown = null;
   }
+  isReady() { return Boolean(this.user && !this.destroyed); }
+  async login(token = this.token) { if (!token) throw new QauTError('Bot token is required'); this.token = token; this.rest.setToken(token); this.user = await this.rest.get('/bot/me'); if (this.keepAlive) this.startKeepAlive(); if (this.polling) this.startPolling(); if (this.registerProcessShutdown) this.attachProcessShutdown(); this.emit(Events.ClientReady, this.user); return token; }
+  async destroy(options = {}) { if (this.destroyed) return this; this.destroyed = true; if (options.setOffline !== false && this.token) await this.setPresence({ status: Status.Offline }).catch(err => this.emit(Events.Debug, `Failed to set offline presence: ${err.message}`)); if (this.keepAliveInterval) clearInterval(this.keepAliveInterval); if (this.pollInterval) clearInterval(this.pollInterval); this.keepAliveInterval = null; this.pollInterval = null; this.user = null; return this; }
+  attachProcessShutdown() { if (this.boundShutdown || typeof process === 'undefined') return this; this.boundShutdown = async () => { await this.destroy(); process.exit(0); }; process.once('SIGINT', this.boundShutdown); process.once('SIGTERM', this.boundShutdown); return this; }
+  startKeepAlive() { if (!this.keepAliveInterval) this.keepAliveInterval = setInterval(() => this.emit(Events.Debug, 'QauT.js keep-alive heartbeat'), 30_000); return this; }
+  startPolling() { if (this.pollInterval) return this; this.gatewayCursor = new Date().toISOString(); const tick = async () => { try { const q = this.gatewayCursor ? `?after=${encodeURIComponent(this.gatewayCursor)}` : ''; const data = await this.rest.get(`/bot/gateway/messages${q}`); this.gatewayCursor = data.cursor || new Date().toISOString(); for (const payload of data.messages || []) this.emitGatewayEvent(Events.MessageCreate, payload); } catch (err) { this.emit(Events.Error, err); } }; this.pollInterval = setInterval(tick, this.pollIntervalMs); return this; }
+  setPresence(presence = {}) { return this.rest.patch('/bot/presence', presence); }
+  setStatus(status) { return this.setPresence({ status }); }
+  generateInvite(options = {}) { const params = new URLSearchParams({ client_id: options.clientId || this.user?.applicationId || this.user?.id || '', scope: (options.scopes || ['bot', 'applications.commands']).join(' '), permissions: String(options.permissions || 0) }); return `https://qaut.gg/oauth2/authorize?${params}`; }
+  fetchInvite(code) { return this.rest.get(`/bot/invites/${code}`); }
+  fetchWebhook(id) { return this.rest.get(`/bot/webhooks/${id}`); }
+  fetchGuildPreview(id) { return this.rest.get(`/bot/guilds/${id}/preview`); }
+  fetchSticker(id) { return this.rest.get(`/bot/stickers/${id}`); }
+  fetchVoiceRegions() { return this.rest.get('/bot/voice-regions'); }
+  fetchPremiumStickerPacks() { return this.rest.get('/bot/sticker-packs'); }
+  fetchApplicationEmojis() { return this.rest.get('/bot/application/emojis'); }
+  fetchGuildTemplate(code) { return this.rest.get(`/bot/guild-templates/${code}`); }
+  fetchStageInstance(id) { return this.rest.get(`/bot/stage-instances/${id}`); }
+  fetchGuildWidget(id) { return this.rest.get(`/bot/guilds/${id}/widget`); }
+  fetchGuildWidgetImage(id) { return `${this.rest.baseUrl}/bot/guilds/${id}/widget.png`; }
+  fetchGuildWidgetSettings(id) { return this.rest.get(`/bot/guilds/${id}/widget/settings`); }
+  channel(id) { return new Channel(this, { id }); }
+  guild(id) { return new Guild(this, { id }); }
+  user(id) { return new User(this, { id }); }
+  emitGatewayEvent(eventName, payload) { if (eventName === Events.MessageCreate || eventName === 'messageCreate') return this.emit('messageCreate', new Message(this, payload)); return this.emit(eventName, payload); }
 }
 
-function CreateEmbed(data) {
-  return new EmbedBuilder(data);
-}
-
-function normalizeMessagePayload(payload) {
-  if (typeof payload === 'string') return { content: payload };
-  const output = { ...payload };
-  if (output.embeds) output.embeds = output.embeds.map(toJSON);
-  if (output.components) output.components = output.components.map(toJSON);
-  return output;
-}
-
-function normalizeColor(color) {
-  if (typeof color === 'number') return color;
-  const value = String(color).replace('#', '');
-  return Number.parseInt(value, 16);
-}
-
-function toJSON(value) {
-  return value && typeof value.toJSON === 'function' ? value.toJSON() : value;
-}
-
-function serialize(value) {
-  return JSON.parse(JSON.stringify(value, (_key, item) => typeof item === 'bigint' ? item.toString() : toJSON(item)));
-}
+function commandManager(client, base) { return { create: data => client.rest.post(base, toJSON(data)), fetch: id => client.rest.get(id ? `${base}/${id}` : base), edit: (id, data) => client.rest.patch(`${base}/${id}`, toJSON(data)), delete: id => client.rest.delete(`${base}/${id}`) }; }
+function permissionOverwriteManager(client, base) { return { create: (id, data) => client.rest.put(`${base}/${id}`, data), edit: (id, data) => client.rest.patch(`${base}/${id}`, data), delete: id => client.rest.delete(`${base}/${id}`) }; }
+function roleMemberManager(client, guildId, memberId) { return { add: id => client.rest.put(`/bot/guilds/${guildId}/members/${memberId}/roles/${id}`, {}), remove: id => client.rest.delete(`/bot/guilds/${guildId}/members/${memberId}/roles/${id}`), set: ids => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/roles`, { roleIds: idsOf(ids) }), fetch: () => client.rest.get(`/bot/guilds/${guildId}/members/${memberId}/roles`) }; }
+function voiceMemberManager(client, guildId, memberId) { return { disconnect: () => client.rest.delete(`/bot/guilds/${guildId}/members/${memberId}/voice`), setMute: v => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/voice`, { muted: Boolean(v) }), setDeaf: v => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/voice`, { deafened: Boolean(v) }), setChannel: id => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/voice`, { channelId: idOf(id) }), setSuppressed: v => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/voice`, { suppressed: Boolean(v) }), setRequestToSpeak: v => client.rest.patch(`/bot/guilds/${guildId}/members/${memberId}/voice`, { requestToSpeak: Boolean(v) }) }; }
+
+function joinVoiceChannel(options = {}) { return new VoiceConnection(options); }
+function createAudioPlayer() { return new AudioPlayer(); }
+function createAudioResource(input, options = {}) { return { input, ...options }; }
+function createAudioReceiver() { return new EventEmitter(); }
+function entersState(target) { return Promise.resolve(target); }
+function getVoiceConnection() { return null; }
+class AudioPlayer extends EventEmitter { play(resource) { this.resource = resource; this.emit('play', resource); return this; } pause() { this.paused = true; return true; } unpause() { this.paused = false; return true; } stop() { this.emit('stop'); return true; } }
+class VoiceConnection extends EventEmitter { constructor(options) { super(); this.options = options; } subscribe(player) { this.player = player; return { unsubscribe() {} }; } destroy() { this.emit('destroy'); } }
+
+function time(date = new Date(), style) { const ts = Math.floor(new Date(date).getTime() / 1000); return style ? `<t:${ts}:${style}>` : `<t:${ts}>`; }
+const userMention = id => `<@${idOf(id)}>`;
+const roleMention = id => `<@&${idOf(id)}>`;
+const channelMention = id => `<#${idOf(id)}>`;
+const chatInputApplicationCommandMention = (name, id) => `</${name}:${id}>`;
+const inlineCode = v => `\`${escapeMarkdown(String(v))}\``;
+const codeBlock = (lang, code) => code === undefined ? `\`\`\`\n${lang}\n\`\`\`` : `\`\`\`${lang}\n${code}\n\`\`\``;
+const bold = v => `**${v}**`;
+const italic = v => `*${v}*`;
+const underline = v => `__${v}__`;
+const strikethrough = v => `~~${v}~~`;
+const spoiler = v => `||${v}||`;
+const quoteBlock = v => `>>> ${v}`;
+const blockQuote = quoteBlock;
+const escapeMarkdown = v => String(v).replace(/([\\`*_{}[\]()#+\-.!|>~])/g, '\\$1');
+const hideLinkEmbed = url => `<${url}>`;
+const hyperlink = (text, url) => `[${text}](${url})`;
+
+function CreateEmbed(data) { return new EmbedBuilder(data); }
+function normalizeMessagePayload(payload) { if (typeof payload === 'string') return { content: payload }; const out = { ...payload }; if (out.embeds) out.embeds = out.embeds.map(toJSON); if (out.components) out.components = out.components.map(toJSON); return out; }
+function normalizeColor(color) { if (typeof color === 'number') return color; return Number.parseInt(String(color).replace('#', ''), 16); }
+function normalizeField(field) { return { name: String(field.name).slice(0, 256), value: String(field.value).slice(0, 1024), inline: Boolean(field.inline) }; }
+function normalizeOption(type, option) { const data = typeof option?.toJSON === 'function' ? option.toJSON() : option || {}; return { type, ...data }; }
+function toJSON(value) { return value && typeof value.toJSON === 'function' ? value.toJSON() : value; }
+function serialize(value) { return JSON.parse(JSON.stringify(value, (_k, item) => typeof item === 'bigint' ? item.toString() : toJSON(item))); }
+function structuredCloneSafe(value) { return JSON.parse(JSON.stringify(value, (_k, item) => typeof item === 'bigint' ? item.toString() : toJSON(item))); }
+function idOf(value) { return typeof value === 'object' && value ? value.id : value; }
+function idsOf(values) { return Array.isArray(values) ? values.map(idOf) : [idOf(values)]; }
 
 module.exports = {
-  ActionRowBuilder,
-  ActivityType,
-  BitField,
-  ButtonBuilder,
-  Client,
-  CreateEmbed,
-  DefaultRestBase,
-  EmbedBuilder,
-  Events,
-  GatewayIntentBits,
-  IntentBitField,
-  Message,
-  PermissionBitField,
-  PermissionFlagsBits,
-  QauTError,
-  REST,
-  SlashCommandBuilder,
-  Status,
-  TextChannel
-  , User
+  ActionRowBuilder, ActivityType, AttachmentBuilder, BitField, ButtonBuilder, Channel, ChannelSelectMenuBuilder,
+  Client, Collection, ContextMenuCommandBuilder, CreateEmbed, DefaultRestBase, EmbedBuilder, Emoji, Events,
+  GatewayIntentBits, Guild, GuildMember, IntentBitField, Interaction, Invite, Message, ModalBuilder,
+  PermissionBitField, PermissionsBitField, PermissionFlagsBits, Partials, QauTError, REST, Reaction, Role,
+  RoleSelectMenuBuilder, ScheduledEvent, SelectMenuBuilder, SlashCommandBuilder, Status, Sticker,
+  StringSelectMenuBuilder, TextChannel, TextInputBuilder, Thread, User, UserSelectMenuBuilder, Webhook,
+  MentionableSelectMenuBuilder, StringOption, IntegerOption, BooleanOption, UserOption, RoleOption,
+  MentionableOption, NumberOption, ChannelOption, AttachmentOption,
+  joinVoiceChannel, createAudioPlayer, createAudioResource, createAudioReceiver, entersState, getVoiceConnection,
+  time, userMention, roleMention, channelMention, chatInputApplicationCommandMention, inlineCode, codeBlock,
+  bold, italic, underline, strikethrough, spoiler, quoteBlock, blockQuote, escapeMarkdown, hideLinkEmbed, hyperlink
 };