baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/collectors/Collector.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collector = exports.CollectorError = void 0;
+exports.awaitCollector = awaitCollector;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const Collection_js_1 = require("../util/Collection.js");
+const TypedEmitter_js_1 = require("../util/TypedEmitter.js");
+class CollectorError extends BaffError_js_1.BaffError {
+    collected;
+    reason;
+    constructor(collected, reason) {
+        super('COLLECTOR_ENDED', `The collector ended with reason "${reason}".`);
+        this.collected = collected;
+        this.reason = reason;
+        this.name = 'CollectorError';
+    }
+}
+exports.CollectorError = CollectorError;
+class Collector extends TypedEmitter_js_1.TypedEmitter {
+    options;
+    collected = new Collection_js_1.Collection();
+    ended = false;
+    endReason = null;
+    processed = 0;
+    timer = null;
+    idleTimer = null;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        if (options.time)
+            this.timer = setTimeout(() => this.stop('time'), options.time);
+        this.resetIdle();
+    }
+    async handle(item) {
+        if (this.ended)
+            return;
+        this.processed++;
+        const pass = this.options.filter ? await this.options.filter(item, this.collected) : true;
+        if (this.ended)
+            return;
+        if (pass) {
+            this.collected.set(this.keyOf(item), item);
+            this.emit('collect', item);
+            this.resetIdle();
+        }
+        else {
+            this.emit('ignore', item);
+        }
+        if (this.options.max && this.collected.size >= this.options.max)
+            this.stop('limit');
+        else if (this.options.maxProcessed && this.processed >= this.options.maxProcessed)
+            this.stop('processedLimit');
+    }
+    stop(reason = 'user') {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.endReason = reason;
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.cleanup();
+        this.emit('end', this.collected, reason);
+    }
+    resetIdle() {
+        if (!this.options.idle)
+            return;
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => this.stop('idle'), this.options.idle);
+    }
+}
+exports.Collector = Collector;
+function awaitCollector(collector, errors = []) {
+    return new Promise((resolve, reject) => {
+        collector.once('end', (collected, reason) => {
+            if (errors.includes(reason))
+                reject(new CollectorError(collected, reason));
+            else
+                resolve(collected);
+        });
+    });
+}

package/dist/cjs/collectors/InteractionCollector.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from '../client/Client.js';
+import type { BaseInteraction } from '../structures/interactions/BaseInteraction.js';
+import { Collector, type CollectorOptions } from './Collector.js';
+export interface InteractionCollectorOptions extends CollectorOptions<BaseInteraction> {
+    channelId?: string;
+    serverId?: string;
+    messageId?: string;
+    customId?: string;
+    componentType?: number;
+    userId?: string;
+    interactionType?: 'component' | 'modal_submit' | 'command';
+}
+export declare class InteractionCollector extends Collector<BaseInteraction> {
+    private readonly client;
+    private readonly criteria;
+    private readonly listener;
+    constructor(client: Client, criteria?: InteractionCollectorOptions);
+    protected keyOf(interaction: BaseInteraction): string;
+    protected cleanup(): void;
+    private matches;
+}

package/dist/cjs/collectors/InteractionCollector.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionCollector = void 0;
+const Collector_js_1 = require("./Collector.js");
+class InteractionCollector extends Collector_js_1.Collector {
+    client;
+    criteria;
+    listener = (interaction) => {
+        if (this.matches(interaction))
+            void this.handle(interaction);
+    };
+    constructor(client, criteria = {}) {
+        super(criteria);
+        this.client = client;
+        this.criteria = criteria;
+        client.on('interactionCreate', this.listener);
+    }
+    keyOf(interaction) {
+        return interaction.id;
+    }
+    cleanup() {
+        this.client.off('interactionCreate', this.listener);
+    }
+    matches(i) {
+        const c = this.criteria;
+        const kind = c.interactionType ?? 'component';
+        if (kind === 'component' ? !i.isMessageComponent() : kind === 'modal_submit' ? !i.isModalSubmit() : !i.isChatInputCommand())
+            return false;
+        if (c.channelId && i.channelId !== c.channelId)
+            return false;
+        if (c.serverId && i.serverId !== c.serverId)
+            return false;
+        if (c.userId && i.user.id !== c.userId)
+            return false;
+        if (c.messageId && i.message?.id !== c.messageId)
+            return false;
+        if (c.customId && (i.isMessageComponent() || i.isModalSubmit() ? i.customId : null) !== c.customId)
+            return false;
+        if (c.componentType !== undefined && (!i.isMessageComponent() || i.componentType !== c.componentType))
+            return false;
+        return true;
+    }
+}
+exports.InteractionCollector = InteractionCollector;

package/dist/cjs/collectors/MessageCollector.d.ts

@@ -0,0 +1,14 @@
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import type { Message } from '../structures/Message.js';
+import { Collector, type CollectorOptions } from './Collector.js';
+export type MessageCollectorOptions = CollectorOptions<Message>;
+export interface AwaitMessagesOptions extends MessageCollectorOptions {
+    errors?: string[];
+}
+export declare class MessageCollector extends Collector<Message> {
+    readonly channel: TextBasedChannel;
+    private readonly listener;
+    constructor(channel: TextBasedChannel, options?: MessageCollectorOptions);
+    protected keyOf(message: Message): string;
+    protected cleanup(): void;
+}

package/dist/cjs/collectors/MessageCollector.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCollector = void 0;
+const Collector_js_1 = require("./Collector.js");
+class MessageCollector extends Collector_js_1.Collector {
+    channel;
+    listener = (message) => {
+        if (message.channelId === this.channel.id)
+            void this.handle(message);
+    };
+    constructor(channel, options = {}) {
+        super(options);
+        this.channel = channel;
+        channel.client.on('messageCreate', this.listener);
+    }
+    keyOf(message) {
+        return message.id;
+    }
+    cleanup() {
+        this.channel.client.off('messageCreate', this.listener);
+    }
+}
+exports.MessageCollector = MessageCollector;

package/dist/cjs/errors/BaffError.d.ts

@@ -0,0 +1,26 @@
+export declare class BaffError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface APIErrorBody {
+    error?: {
+        code?: string;
+        message?: string;
+        field?: string | null;
+        limitedUntil?: string;
+    };
+}
+export declare class BaffAPIError extends BaffError {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    readonly field: string | null;
+    readonly body: unknown;
+    constructor(status: number, method: string, path: string, body: unknown);
+}
+export declare class BaffRateLimitError extends BaffAPIError {
+    readonly retryAfter: number;
+    constructor(method: string, path: string, body: unknown, retryAfter: number);
+}

package/dist/cjs/errors/BaffError.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaffRateLimitError = exports.BaffAPIError = exports.BaffError = void 0;
+class BaffError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'BaffError';
+        this.code = code;
+    }
+}
+exports.BaffError = BaffError;
+class BaffAPIError extends BaffError {
+    status;
+    method;
+    path;
+    field;
+    body;
+    constructor(status, method, path, body) {
+        const detail = body?.error;
+        super(detail?.code ?? `HTTP_${status}`, detail?.message ?? `${method} ${path} failed with status ${status}.`);
+        this.name = 'BaffAPIError';
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.field = detail?.field ?? null;
+        this.body = body;
+    }
+}
+exports.BaffAPIError = BaffAPIError;
+class BaffRateLimitError extends BaffAPIError {
+    retryAfter;
+    constructor(method, path, body, retryAfter) {
+        super(429, method, path, body);
+        this.name = 'BaffRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+exports.BaffRateLimitError = BaffRateLimitError;

package/dist/cjs/gateway/Gateway.d.ts

@@ -0,0 +1,53 @@
+import { TypedEmitter } from '../util/TypedEmitter.js';
+export interface WebSocketLike {
+    readyState: number;
+    close(code?: number, reason?: string): void;
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((event: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+export type WebSocketConstructor = new (url: string, options?: {
+    headers?: Record<string, string>;
+}) => WebSocketLike;
+export interface GatewayOptions {
+    url?: string;
+    token: string;
+    WebSocket?: WebSocketConstructor;
+    reconnect?: boolean;
+    initialBackoff?: number;
+    maxBackoff?: number;
+}
+type GatewayEvents = {
+    dispatch: [event: string, data: unknown];
+    ready: [data: unknown];
+    reconnected: [data: unknown];
+    disconnect: [code: number, reason: string];
+    reconnecting: [attempt: number, delay: number];
+    debug: [message: string];
+};
+export declare class Gateway extends TypedEmitter<GatewayEvents> {
+    private readonly options;
+    private socket;
+    private timer;
+    private attempt;
+    private destroyed;
+    private everReady;
+    private readonly url;
+    private readonly WebSocketImpl;
+    private readonly reconnect;
+    private readonly initialBackoff;
+    private readonly maxBackoff;
+    constructor(options: GatewayOptions);
+    get connected(): boolean;
+    connect(): Promise<unknown>;
+    destroy(code?: number, reason?: string): void;
+    private open;
+    private scheduleReconnect;
+}
+export {};

package/dist/cjs/gateway/Gateway.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gateway = void 0;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const constants_js_1 = require("../util/constants.js");
+const TypedEmitter_js_1 = require("../util/TypedEmitter.js");
+const OPEN = 1;
+class Gateway extends TypedEmitter_js_1.TypedEmitter {
+    options;
+    socket = null;
+    timer = null;
+    attempt = 0;
+    destroyed = false;
+    everReady = false;
+    url;
+    WebSocketImpl;
+    reconnect;
+    initialBackoff;
+    maxBackoff;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.url = options.url ?? constants_js_1.DEFAULT_GATEWAY_URL;
+        this.reconnect = options.reconnect ?? true;
+        this.initialBackoff = options.initialBackoff ?? 1000;
+        this.maxBackoff = options.maxBackoff ?? 30_000;
+        this.WebSocketImpl = options.WebSocket ?? defaultWebSocket();
+    }
+    get connected() {
+        return this.socket?.readyState === OPEN;
+    }
+    connect() {
+        this.destroyed = false;
+        return new Promise((resolve, reject) => this.open(resolve, reject));
+    }
+    destroy(code = 1000, reason = 'client destroyed') {
+        this.destroyed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        const socket = this.socket;
+        this.socket = null;
+        if (!socket)
+            return;
+        socket.onclose = socket.onerror = socket.onmessage = socket.onopen = null;
+        try {
+            socket.close(code, reason);
+        }
+        catch {
+            // already closed
+        }
+    }
+    open(resolve, reject) {
+        let socket;
+        try {
+            socket = new this.WebSocketImpl(this.url, { headers: { Authorization: `Bot ${this.options.token}` } });
+        }
+        catch (cause) {
+            const error = new BaffError_js_1.BaffError('GATEWAY_CONNECT', `Could not open the gateway: ${cause.message}`, { cause });
+            if (reject && !this.everReady)
+                return reject(error);
+            return this.scheduleReconnect(resolve, reject);
+        }
+        this.socket = socket;
+        let settled = false;
+        socket.onmessage = (event) => {
+            const frame = parseFrame(event.data);
+            if (!frame)
+                return;
+            if (frame.t === 'READY') {
+                const first = !this.everReady;
+                this.everReady = true;
+                this.attempt = 0;
+                settled = true;
+                this.emit(first ? 'ready' : 'reconnected', frame.d);
+                resolve?.(frame.d);
+                return;
+            }
+            this.emit('dispatch', frame.t, frame.d);
+        };
+        socket.onerror = () => {
+            this.emit('debug', 'socket error');
+        };
+        socket.onclose = (event) => {
+            if (this.socket !== socket)
+                return;
+            this.socket = null;
+            this.emit('disconnect', event.code, event.reason);
+            if (this.destroyed)
+                return;
+            if (!settled && !this.everReady && reject) {
+                reject(new BaffError_js_1.BaffError('GATEWAY_CONNECT', `The gateway closed the connection before READY (code ${event.code}). Check the token and the gateway URL.`));
+                return;
+            }
+            this.scheduleReconnect(resolve, reject);
+        };
+    }
+    scheduleReconnect(resolve, reject) {
+        if (!this.reconnect || this.destroyed)
+            return;
+        const delay = Math.min(this.initialBackoff * 2 ** this.attempt, this.maxBackoff);
+        this.attempt++;
+        this.emit('reconnecting', this.attempt, delay);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (!this.destroyed)
+                this.open(resolve, reject);
+        }, delay);
+    }
+}
+exports.Gateway = Gateway;
+function parseFrame(data) {
+    const text = typeof data === 'string' ? data : data instanceof ArrayBuffer ? new TextDecoder().decode(data) : String(data);
+    try {
+        const frame = JSON.parse(text);
+        return typeof frame.t === 'string' ? { t: frame.t, d: frame.d } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultWebSocket() {
+    const ctor = globalThis.WebSocket;
+    if (typeof ctor !== 'function') {
+        throw new BaffError_js_1.BaffError('NO_WEBSOCKET', 'This runtime has no global WebSocket. Use Node 22+, Bun or Deno, run Node 20 with --experimental-websocket, or pass the ws package as the WebSocket option.');
+    }
+    return ctor;
+}

package/dist/cjs/http/handler.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { Client } from '../client/Client.js';
+import { type VerifyOptions } from './verify.js';
+export interface InteractionsHandlerOptions extends VerifyOptions {
+    secret: string;
+    client?: Client;
+    answerWithinMs?: number;
+}
+export type InteractionsHandler = (request: Request) => Promise<Response>;
+export declare function createInteractionsHandler(options: InteractionsHandlerOptions): InteractionsHandler;
+export declare function toNodeListener(handler: InteractionsHandler): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/cjs/http/handler.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInteractionsHandler = createInteractionsHandler;
+exports.toNodeListener = toNodeListener;
+const Client_js_1 = require("../client/Client.js");
+const createInteraction_js_1 = require("../structures/interactions/createInteraction.js");
+const verify_js_1 = require("./verify.js");
+function createInteractionsHandler(options) {
+    const client = options.client ?? new Client_js_1.Client();
+    const answerWithinMs = options.answerWithinMs ?? 2800;
+    return async (request) => {
+        if (request.method !== 'POST')
+            return new Response('method not allowed', { status: 405 });
+        const body = await request.text();
+        if (!(0, verify_js_1.verifyRequestHeaders)(request.headers, body, options.secret, options))
+            return new Response('bad signature', { status: 401 });
+        let raw;
+        try {
+            raw = JSON.parse(body);
+        }
+        catch {
+            return new Response('bad request', { status: 400 });
+        }
+        if (raw.type === 'ping')
+            return Response.json({ type: 'pong' });
+        client.setApplicationId(raw.applicationId);
+        let respond;
+        const answered = new Promise((resolve) => (respond = resolve));
+        const timeout = new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(new Response(null, { status: 200 })), answerWithinMs);
+            void answered.then(() => clearTimeout(timer));
+        });
+        try {
+            const interaction = (0, createInteraction_js_1.createInteraction)(client, raw);
+            interaction._setSink((answer) => respond(Response.json(answer)));
+            client.emit('interactionCreate', interaction);
+            const response = await Promise.race([answered, timeout]);
+            interaction._setSink(null);
+            return response;
+        }
+        catch (error) {
+            client.emit('debug', `Interaction handler failed: ${error.message}`);
+            return new Response('internal error', { status: 500 });
+        }
+    };
+}
+function toNodeListener(handler) {
+    return (req, res) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (Array.isArray(value))
+                    value.forEach((v) => headers.append(key, v));
+                else if (value !== undefined)
+                    headers.set(key, value);
+            }
+            const request = new Request(`http://${req.headers.host ?? 'localhost'}${req.url ?? '/'}`, {
+                method: req.method,
+                headers,
+                body: req.method === 'GET' || req.method === 'HEAD' ? undefined : Buffer.concat(chunks)
+            });
+            handler(request).then(async (response) => {
+                res.writeHead(response.status, Object.fromEntries(response.headers));
+                res.end(Buffer.from(await response.arrayBuffer()));
+            }, () => {
+                res.writeHead(500).end('internal error');
+            });
+        });
+    };
+}

package/dist/cjs/http/verify.d.ts

@@ -0,0 +1,11 @@
+export declare const SIGNATURE_HEADERS: readonly ["x-bafflux-signature", "x-baff.gg-signature"];
+export declare const TIMESTAMP_HEADERS: readonly ["x-bafflux-timestamp", "x-baff.gg-timestamp"];
+export interface VerifyOptions {
+    toleranceSeconds?: number;
+    now?: () => number;
+}
+export declare function sign(secret: string, timestamp: string | number, body: string | Uint8Array): string;
+export declare function verifyKey(body: string | Uint8Array, signature: string | null | undefined, timestamp: string | null | undefined, secret: string, options?: VerifyOptions): boolean;
+export declare function verifyRequestHeaders(headers: {
+    get(name: string): string | null;
+}, body: string | Uint8Array, secret: string, options?: VerifyOptions): boolean;

package/dist/cjs/http/verify.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_HEADERS = exports.SIGNATURE_HEADERS = void 0;
+exports.sign = sign;
+exports.verifyKey = verifyKey;
+exports.verifyRequestHeaders = verifyRequestHeaders;
+const node_crypto_1 = require("node:crypto");
+exports.SIGNATURE_HEADERS = ['x-bafflux-signature', 'x-baff.gg-signature'];
+exports.TIMESTAMP_HEADERS = ['x-bafflux-timestamp', 'x-baff.gg-timestamp'];
+function sign(secret, timestamp, body) {
+    return (0, node_crypto_1.createHmac)('sha256', secret).update(`${timestamp}.`).update(body).digest('hex');
+}
+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 && (0, node_crypto_1.timingSafeEqual)(given, expected);
+}
+function verifyRequestHeaders(headers, body, secret, options) {
+    const find = (names) => names.map((name) => headers.get(name)).find((value) => value !== null) ?? null;
+    return verifyKey(body, find(exports.SIGNATURE_HEADERS), find(exports.TIMESTAMP_HEADERS), secret, options);
+}

package/dist/cjs/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';