baff.js 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to baff.js are listed here. The project follows [semantic versioning](https://semver.org); before 1.0, minor versions may include breaking changes.
+
+## 0.1.0
+
+First release.
+
+- `Client` with gateway connection, automatic reconnect with backoff, and caches for servers, channels, users, members, roles and messages.
+- Typed events for the gateway events documented at docs.baff.gg, plus `raw`.
+- `REST` with per-route queues, `429` handling, message send spacing, retries for idempotent requests, multipart uploads and typed errors (`BaffError`, `BaffAPIError`, `BaffRateLimitError`).
+- Structures with methods: `Message`, `User`, `ServerMember`, `Server`, `Role`, channels (`TextChannel`, `ThreadChannel`, `DMChannel`, `VoiceChannel`, `CategoryChannel`, `ForumChannel`), `Emoji`, `Sticker`, `Invite`, `Webhook`, `ScheduledEvent`.
+- Slash command builders (`SlashCommandBuilder`, `PrefixCommandBuilder`) checked against the registration rules, and `client.application.commands` / `server.commands`.
+- Interactions: command, button, select menu and modal submit, with `reply`, `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`.
+- Builders for embeds, action rows, buttons, select menus, modals, text inputs and components v2 layouts, validated against the server's limits.
+- `MessageCollector`, `InteractionCollector`, `awaitMessages`, `awaitMessageComponent`.
+- HTTP interactions: `createInteractionsHandler`, `toNodeListener`, `verifyKey` (HMAC-SHA256, constant-time compare, replay window).
+- `PermissionsBitField`, `Snowflake`, `Collection`, mention and markdown formatters, `Colors`, `Routes`.
+- `WebhookClient` for posting through a webhook URL without a bot.
+- Dual ESM and CommonJS builds with type declarations, and no runtime dependencies.

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 baff.gg. All rights reserved.
+
+baff.js is free to use. You may install it and use it, unmodified, to build bots, apps and tools that work with baff.gg, including commercial ones.
+
+You may not redistribute baff.js or a modified version of it, publish it under another name, or use it to build a competing library, without written permission from baff.gg.
+
+baff.js is provided as is, without warranty of any kind. baff.gg is not liable for any damages arising from its use.

package/README.md

@@ -1,3 +1,244 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# baff.js
+
+A library for building bots on [baff.gg](https://baff.gg). It wraps the REST API and the gateway, turns slash commands, buttons, select menus and forms into objects with methods, and validates embeds and components before they leave your process. No runtime dependencies.
+
+If you have used discord.js, the shapes will be familiar: `Client`, event listeners, `interaction.reply()`, builders, collectors, `Collection`, permission bitfields. baff.gg calls guilds **servers**, and the event and type names follow baff.gg's own gateway (`serverCreate`, `memberUpdate`, `ServerMember`).
+
+```bash
+npm install baff.js
+bun add baff.js
+```
+
+## Requirements
+
+- Node.js 22 or newer, Bun, or Deno. The gateway uses the runtime's built-in `WebSocket`, `fetch` and `FormData`.
+- Node.js 20 works too: start it with `--experimental-websocket`, or install the `ws` package and pass it in: `new Client({ WebSocket: WebSocket })`.
+- A bot token and the application id from the [Developer Portal](https://baff.gg/developers). baff.gg does not tell a bot its application id, so pass it as `applicationId` (it is only needed to register commands and to build an install link).
+
+## A first bot
+
+```js
+import { Client, SlashCommandBuilder } from 'baff.js';
+
+const client = new Client({ token: process.env.BOT_TOKEN, applicationId: process.env.APP_ID });
+
+client.once('ready', async () => {
+	await client.requireApplication().commands.set([
+		new SlashCommandBuilder().setName('ping').setDescription('Checks the bot is awake')
+	]);
+	console.log(`Logged in as ${client.user.username}`);
+});
+
+client.on('interactionCreate', async (interaction) => {
+	if (interaction.isChatInputCommand() && interaction.commandName === 'ping') {
+		await interaction.reply('Pong!');
+	}
+});
+
+await client.login();
+```
+
+`commands.set` replaces every global command with the list you pass, like the API's `PUT`. Use `server.commands.set(...)` for commands that belong to one server.
+
+More complete bots are in [`examples/`](./examples): a ping command, buttons with a select menu and a form, an embed with a components v2 layout, and a signed HTTP interactions endpoint.
+
+## Slash commands
+
+```js
+const command = new SlashCommandBuilder()
+	.setName('partner')
+	.setDescription('Manage partnered servers')
+	.addSubcommand((sub) =>
+		sub.setName('add').setDescription('Partner a server').addStringOption((o) => o.setName('server').setDescription('Name or id').setRequired(true))
+	)
+	.addSubcommandGroup((group) =>
+		group.setName('settings').setDescription('Settings').addSubcommand((sub) => sub.setName('show').setDescription('Show them'))
+	);
+```
+
+`toJSON()` (called by `commands.set`) applies the same checks the server does and throws a `BaffError` that names the problem: names of 1-32 lowercase letters, numbers, `-` or `_`, descriptions of 1-100 characters, at most 25 options, required options before optional ones, and a command that holds either subcommands or plain options, never both.
+
+Option types are `string`, `integer`, `number`, `boolean`, `user`, `channel` and `role`. baff.gg does not support choices, autocomplete or min/max values on options, so there are no builder methods for them.
+
+Read the values with `interaction.options`:
+
+```js
+const text = interaction.options.getString('text', true); // string, throws if missing
+const times = interaction.options.getInteger('times');    // number | null
+const sub = interaction.options.getSubcommand();          // 'add'
+const group = interaction.options.getSubcommandGroup();   // 'settings' | null
+const userId = interaction.options.getUserId('who');      // user, role and channel options arrive as ids
+const user = interaction.options.getUser('who');          // from the cache, or null
+const fetched = await interaction.options.fetchUser('who');
+```
+
+Prefix commands (the `!help` kind, which only show up in the command picker) use `PrefixCommandBuilder`.
+
+### Replying
+
+```js
+await interaction.reply({ content: 'Only you can see this', ephemeral: true });
+await interaction.deferReply();            // "Bot is thinking..."
+await interaction.editReply('Done');       // after a defer, this sends the real answer
+await interaction.followUp('One more');    // up to 15 minutes after the interaction
+await interaction.showModal(modal);
+```
+
+You have 3 seconds to answer or defer. Two things work differently from what you might expect, because of what the baff.gg API offers:
+
+- After the first answer, `editReply` and `deleteReply` on a command look the reply message up in the channel (by command name and author) and edit it with your bot token. If the same person runs the same command several times at once in one channel, it can pick the wrong message.
+- Ephemeral replies are not stored, so they cannot be edited or deleted afterwards. Answer a component click with `update()` to change an ephemeral message that has components.
+
+## Components, embeds and layouts
+
+```js
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder, EmbedBuilder, Colors } from 'baff.js';
+
+await channel.send({
+	embeds: [new EmbedBuilder().setTitle('Deploy finished').setDescription('**v1.4.2** is live').setColor(Colors.Baff)],
+	components: [
+		new ActionRowBuilder().addComponents(
+			new ButtonBuilder().setCustomId('ok').setLabel('Nice').setStyle(ButtonStyle.Success),
+			new ButtonBuilder().setLabel('Notes').setURL('https://example.com/notes')
+		),
+		new ActionRowBuilder().addComponents(
+			new StringSelectMenuBuilder().setCustomId('pick').addOptions({ label: 'A', value: 'a' }, { label: 'B', value: 'b' })
+		)
+	]
+});
+```
+
+Builders: `EmbedBuilder`, `ActionRowBuilder`, `ButtonBuilder`, `StringSelectMenuBuilder`, `UserSelectMenuBuilder`, `RoleSelectMenuBuilder`, `MentionableSelectMenuBuilder`, `ChannelSelectMenuBuilder`, `ModalBuilder`, `TextInputBuilder`, and for components v2 `ContainerBuilder`, `SectionBuilder`, `TextDisplayBuilder`, `ThumbnailBuilder`, `MediaGalleryBuilder`, `SeparatorBuilder`.
+
+Embed and component limits (10 embeds, 6000 characters, 25 fields, 5 rows, 40 components, 4000 characters of text displays, unique custom ids) are checked when the builder is turned into JSON, so the error shows up in your code with the field name instead of as a rejected request. Pass a layout component and the `IsComponentsV2` flag is set for you; such a message cannot also carry `content` or `embeds`.
+
+Clicks arrive as interactions:
+
+```js
+client.on('interactionCreate', async (interaction) => {
+	if (interaction.isButton()) await interaction.update({ content: `${interaction.customId} pressed`, components: [] });
+	if (interaction.isStringSelectMenu()) await interaction.reply({ content: interaction.values.join(', '), ephemeral: true });
+	if (interaction.isModalSubmit()) await interaction.reply(interaction.fields.getTextInputValue('topic'));
+});
+```
+
+User, role, mentionable and channel selects expose `users`, `roles` and `channels` for what was picked.
+
+## Collectors
+
+```js
+const answers = await channel.awaitMessages({ filter: (m) => m.author.id === userId, max: 1, time: 30_000, errors: ['time'] });
+
+const click = await message.awaitMessageComponent({ time: 60_000, filter: (i) => i.user.id === userId });
+
+const collector = message.createMessageComponentCollector({ time: 60_000 });
+collector.on('collect', (interaction) => interaction.deferUpdate());
+collector.on('end', (collected, reason) => console.log(reason));
+```
+
+`awaitMessages` rejects with a `CollectorError` (which carries `collected` and `reason`) when the collector ends for one of the reasons in `errors`. `awaitMessageComponent` rejects on timeout. Both `MessageCollector` and `InteractionCollector` are exported.
+
+## HTTP interactions
+
+If you set an Interactions Endpoint URL in the portal, baff.gg POSTs interactions there instead of sending them on the gateway. `createInteractionsHandler` verifies the signature, answers pings, and hands each interaction to your `interactionCreate` listener:
+
+```js
+import { createServer } from 'node:http';
+import { Client, createInteractionsHandler, toNodeListener } from 'baff.js';
+
+const client = new Client({ token: process.env.BOT_TOKEN, applicationId: process.env.APP_ID });
+client.on('interactionCreate', (interaction) => interaction.isChatInputCommand() && interaction.reply('Pong!'));
+
+createServer(toNodeListener(createInteractionsHandler({ secret: process.env.SIGNING_SECRET, client }))).listen(3000);
+```
+
+The first answer you give is returned as the HTTP response, which is what serverless hosts need; later answers (`followUp`, `editReply`) go through the REST API. The handler is a plain `(Request) => Promise<Response>`, so it also works as a Cloudflare Worker, Bun or Deno handler. Without a gateway connection you do not need to call `login()`.
+
+To check signatures yourself:
+
+```js
+import { verifyKey } from 'baff.js';
+
+verifyKey(rawBody, signatureHeader, timestampHeader, signingSecret); // boolean
+```
+
+The signature is the hex HMAC-SHA256 of `timestamp + "." + body`. `verifyKey` compares in constant time and rejects timestamps more than 5 minutes away from now (`{ toleranceSeconds }` changes that). Pass the raw body exactly as received.
+
+## Errors and rate limits
+
+Every failure is a `BaffError` with a stable `code`. API failures are `BaffAPIError`, with `status`, `method`, `path`, `field` and the parsed `body`:
+
+```js
+try {
+	await channel.send({ embeds: [{ title: 'x'.repeat(300) }] });
+} catch (error) {
+	if (error instanceof BaffAPIError) console.log(error.status, error.code, error.field);
+}
+```
+
+`REST` queues requests per route, waits out `429` responses (using `Retry-After` when the server sends it), spaces message sends to the 5 per 5 seconds baff.gg allows, and retries `GET`, `PUT` and `DELETE` after network errors and `5xx` answers. A `429` with the code `slowmode` is a channel rule, not a throttle, so it is thrown at once as a `BaffRateLimitError`.
+
+## Permissions, snowflakes and formatting
+
+```js
+import { PermissionsBitField, PermissionFlagsBits, Snowflake, userMention, escapeMarkdown } from 'baff.js';
+
+const perms = new PermissionsBitField(['ViewChannel', 'SendMessages']);
+perms.has('SendMessages');                    // true
+perms.missing(['BanMembers']);                // ['BanMembers']
+interaction.memberPermissions?.has('BanMembers');  // channel-accurate, from the interaction
+member.permissions;                           // server-wide, from role bits (channel overrides are not applied)
+
+Snowflake.deconstruct('103745999999999999').date;
+userMention(user.id);                         // <@id>
+```
+
+Permission bits are bigints. Ids are strings, as in the API.
+
+## Servers, channels and caches
+
+```js
+const server = await client.servers.fetch('103700000000000000');
+server.channels.cache.find((c) => c.name === 'general');
+await server.members.fetch();                 // one request, fills server.members.cache
+await server.members.ban(userId, { reason: 'spam' });
+await server.roles.create({ name: 'Mods', color: '#2ec4b6', permissions: ['KickMembers'] });
+await server.invites.create({ maxUses: 5 });
+```
+
+On login the client loads every server the bot is in (one list request plus one request per server) so `client.servers`, `client.channels` and the roles are ready when `ready` fires. Pass `fetchServersOnReady: false` to skip that, and `fetchMembersOnReady: true` to also load the member lists. baff.gg has no route for a single channel, so `client.channels.fetch(id)` reloads the bot's servers and DMs to find it.
+
+Events keep the caches in step. The gateway does not replay what happened while the bot was disconnected: after a reconnect the client reloads its servers and then emits `reconnected`.
+
+## Events
+
+`ready`, `reconnecting`, `reconnected`, `disconnect`, `raw`, `debug`, `error`, `serverCreate`, `serverUpdate`, `serverRemove`, `channelCreate`, `channelUpdate`, `channelDelete`, `roleCreate`, `roleUpdate`, `roleDelete`, `threadCreate`, `threadUpdate`, `messageCreate`, `messageUpdate`, `messageDelete`, `messageReactionAdd`, `messageReactionRemove`, `messagePin`, `typingStart`, `mention`, `pollVote`, `memberAdd`, `memberRemove`, `memberUpdate`, `presenceUpdate`, `userUpdate`, `clanTagUpdate`, `dmOpen`, `voiceStateUpdate`, `soundboardPlay`, `callAlone`, `stageInstanceCreate`, `stageInstanceUpdate`, `stageInstanceDelete`, `voiceChannelStatusUpdate`, `serverStickersUpdate`, `serverSoundboardUpdate`, `serverEventCreate`, `serverEventUpdate`, `serverEventDelete`, `serverEventUserAdd`, `serverEventUserRemove`, `interactionCreate`.
+
+Each one maps to a gateway event of the same name in [the docs](https://docs.baff.gg/gateway) (`MESSAGE_CREATE` is `messageCreate`). Events that describe something that may not be cached, like `messageDelete` or `messageReactionAdd`, pass a single object with the ids and whatever could be resolved, instead of a partial structure. `raw` receives every packet, including ones this version does not know yet.
+
+An exception thrown inside a listener is emitted as `error`. With no `error` listener it is rethrown, so it is never silent.
+
+## Voice
+
+Bots can join a voice channel and play audio but never listen. baff.js does not include a media library: `channel.join()` (or `client.voice.join(channelId)`) returns the LiveKit address and token, and you connect with LiveKit's own SDK. See [Voice for bots](https://docs.baff.gg/voice). `client.voice.leave(serverId)` takes the bot out again.
+
+## What bots cannot do
+
+baff.js only wraps routes a bot may call. Friends, creating servers, joining by invite, reporting, group DM calls, the portal, forwarding messages and voting in polls are refused by the platform for bot tokens, so there are no methods for them. Stage channels, soundboard, scheduled-message and AutoMod routes are not wrapped in this version.
+
+## Versioning
+
+baff.js follows semver. Until 1.0, minor versions may change types and method names; the [changelog](./CHANGELOG.md) lists every change. The API shapes come from the baff.gg docs, so a new field on the server shows up in `raw` events and in structures' `toJSON()` before it gets a typed property.
+
+## Development
+
+```bash
+npm install
+npm run typecheck   # strict tsc over src and test, including the type tests
+npm test            # builds the tests and runs them against a fake gateway and REST server
+npm run build       # dist/esm and dist/cjs with declarations
+```
+
+## License
+
+Free to use for building anything that works with baff.gg. Not open source: see the LICENSE file.

package/dist/cjs/builders/EmbedBuilder.d.ts

@@ -0,0 +1,51 @@
+import type { APIEmbed } from '../types.js';
+export declare const EmbedLimits: {
+    readonly embeds: 10;
+    readonly fields: 25;
+    readonly title: 256;
+    readonly description: 4096;
+    readonly fieldName: 256;
+    readonly fieldValue: 1024;
+    readonly footer: 2048;
+    readonly author: 256;
+    readonly total: 6000;
+};
+export type ColorResolvable = number | `#${string}` | readonly [number, number, number];
+export declare function resolveColor(color: ColorResolvable): number;
+export declare class EmbedBuilder {
+    readonly data: APIEmbed;
+    constructor(data?: APIEmbed);
+    setTitle(title: string | null): this;
+    setDescription(description: string | null): this;
+    setURL(value: string | null): this;
+    setColor(color: ColorResolvable | null): this;
+    setTimestamp(timestamp?: Date | number | string | null): this;
+    setAuthor(author: {
+        name: string;
+        url?: string;
+        iconURL?: string;
+    } | null): this;
+    setFooter(footer: {
+        text: string;
+        iconURL?: string;
+    } | null): this;
+    setThumbnail(imageURL: string | null): this;
+    setImage(imageURL: string | null): this;
+    addFields(...fields: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[]): this;
+    setFields(...fields: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[]): this;
+    spliceFields(index: number, deleteCount: number, ...fields: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[]): this;
+    get length(): number;
+    toJSON(): APIEmbed;
+}

package/dist/cjs/builders/EmbedBuilder.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedBuilder = exports.EmbedLimits = void 0;
+exports.resolveColor = resolveColor;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const validate_js_1 = require("./validate.js");
+exports.EmbedLimits = {
+    embeds: 10,
+    fields: 25,
+    title: 256,
+    description: 4096,
+    fieldName: 256,
+    fieldValue: 1024,
+    footer: 2048,
+    author: 256,
+    total: 6000
+};
+function resolveColor(color) {
+    if (typeof color === 'number')
+        return (0, validate_js_1.range)('INVALID_EMBED', 'color', color, 0, 0xffffff);
+    if (typeof color === 'string') {
+        if (!/^#[0-9a-f]{6}$/i.test(color))
+            return (0, validate_js_1.fail)('INVALID_EMBED', 'color', 'must be #rrggbb.');
+        return parseInt(color.slice(1), 16);
+    }
+    const [r, g, b] = color;
+    return ((0, validate_js_1.range)('INVALID_EMBED', 'color', r, 0, 255) << 16) | ((0, validate_js_1.range)('INVALID_EMBED', 'color', g, 0, 255) << 8) | (0, validate_js_1.range)('INVALID_EMBED', 'color', b, 0, 255);
+}
+class EmbedBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = { ...data, fields: data.fields ? data.fields.map((f) => ({ ...f })) : undefined };
+    }
+    setTitle(title) {
+        this.data.title = title ?? undefined;
+        return this;
+    }
+    setDescription(description) {
+        this.data.description = description ?? undefined;
+        return this;
+    }
+    setURL(value) {
+        this.data.url = value ?? undefined;
+        return this;
+    }
+    setColor(color) {
+        this.data.color = color === null ? undefined : resolveColor(color);
+        return this;
+    }
+    setTimestamp(timestamp = new Date()) {
+        if (timestamp === null)
+            this.data.timestamp = undefined;
+        else {
+            const date = new Date(timestamp);
+            if (Number.isNaN(date.getTime()))
+                throw new BaffError_js_1.BaffError('INVALID_EMBED', 'timestamp is not a valid date.');
+            this.data.timestamp = date.toISOString();
+        }
+        return this;
+    }
+    setAuthor(author) {
+        this.data.author = author ? { name: author.name, url: author.url, icon_url: author.iconURL } : undefined;
+        return this;
+    }
+    setFooter(footer) {
+        this.data.footer = footer ? { text: footer.text, icon_url: footer.iconURL } : undefined;
+        return this;
+    }
+    setThumbnail(imageURL) {
+        this.data.thumbnail = imageURL ? { url: imageURL } : undefined;
+        return this;
+    }
+    setImage(imageURL) {
+        this.data.image = imageURL ? { url: imageURL } : undefined;
+        return this;
+    }
+    addFields(...fields) {
+        this.data.fields = [...(this.data.fields ?? []), ...fields];
+        return this;
+    }
+    setFields(...fields) {
+        this.data.fields = [...fields];
+        return this;
+    }
+    spliceFields(index, deleteCount, ...fields) {
+        const next = [...(this.data.fields ?? [])];
+        next.splice(index, deleteCount, ...fields);
+        this.data.fields = next;
+        return this;
+    }
+    get length() {
+        const d = this.data;
+        const size = (s) => [...(s ?? '')].length;
+        return size(d.title) + size(d.description) + size(d.footer?.text) + size(d.author?.name) + (d.fields ?? []).reduce((sum, f) => sum + size(f.name) + size(f.value), 0);
+    }
+    toJSON() {
+        const d = this.data;
+        const code = 'INVALID_EMBED';
+        const out = {};
+        const title = (0, validate_js_1.text)(code, 'title', d.title, exports.EmbedLimits.title, { optional: true });
+        const description = (0, validate_js_1.text)(code, 'description', d.description, exports.EmbedLimits.description, { optional: true });
+        if (title !== undefined)
+            out.title = title;
+        if (description !== undefined)
+            out.description = description;
+        const link = (0, validate_js_1.url)(code, 'url', d.url);
+        if (link)
+            out.url = link;
+        if (d.color !== undefined)
+            out.color = (0, validate_js_1.range)(code, 'color', d.color, 0, 0xffffff);
+        if (d.timestamp)
+            out.timestamp = d.timestamp;
+        if (d.footer) {
+            out.footer = { text: (0, validate_js_1.text)(code, 'footer.text', d.footer.text, exports.EmbedLimits.footer) };
+            const icon = (0, validate_js_1.url)(code, 'footer.iconURL', d.footer.icon_url);
+            if (icon)
+                out.footer.icon_url = icon;
+        }
+        if (d.author) {
+            out.author = { name: (0, validate_js_1.text)(code, 'author.name', d.author.name, exports.EmbedLimits.author) };
+            const authorUrl = (0, validate_js_1.url)(code, 'author.url', d.author.url);
+            const icon = (0, validate_js_1.url)(code, 'author.iconURL', d.author.icon_url);
+            if (authorUrl)
+                out.author.url = authorUrl;
+            if (icon)
+                out.author.icon_url = icon;
+        }
+        for (const key of ['image', 'thumbnail']) {
+            const media = d[key];
+            if (media)
+                out[key] = { url: (0, validate_js_1.url)(code, key, media.url, false) };
+        }
+        if (d.fields?.length) {
+            if (d.fields.length > exports.EmbedLimits.fields)
+                (0, validate_js_1.fail)(code, 'fields', `can have up to ${exports.EmbedLimits.fields} entries.`);
+            out.fields = d.fields.map((f, i) => ({
+                name: (0, validate_js_1.text)(code, `fields[${i}].name`, f.name, exports.EmbedLimits.fieldName),
+                value: (0, validate_js_1.text)(code, `fields[${i}].value`, f.value, exports.EmbedLimits.fieldValue),
+                inline: f.inline ?? false
+            }));
+        }
+        if (!Object.keys(out).filter((k) => k !== 'color' && k !== 'timestamp' && k !== 'url').length) {
+            (0, validate_js_1.fail)(code, 'embed', 'is empty: give it a title, description, fields, image, thumbnail, author or footer.');
+        }
+        if (this.length > exports.EmbedLimits.total)
+            (0, validate_js_1.fail)(code, 'embed', `has ${this.length} characters; the limit is ${exports.EmbedLimits.total} across all of a message's embeds.`);
+        return out;
+    }
+}
+exports.EmbedBuilder = EmbedBuilder;

package/dist/cjs/builders/SlashCommandBuilder.d.ts

@@ -0,0 +1,69 @@
+import type { APICommand, APICommandOption } from '../types.js';
+declare abstract class Named {
+    protected name?: string;
+    protected description?: string;
+    setName(name: string): this;
+    setDescription(description: string): this;
+    protected header(path: string): {
+        name: string;
+        description: string;
+    };
+}
+export declare abstract class OptionBuilder extends Named {
+    protected required: boolean;
+    abstract readonly type: string;
+    setRequired(required?: boolean): this;
+    toJSON(path?: string): APICommandOption;
+}
+export declare class StringOption extends OptionBuilder {
+    readonly type = "string";
+}
+export declare class IntegerOption extends OptionBuilder {
+    readonly type = "integer";
+}
+export declare class NumberOption extends OptionBuilder {
+    readonly type = "number";
+}
+export declare class BooleanOption extends OptionBuilder {
+    readonly type = "boolean";
+}
+export declare class UserOption extends OptionBuilder {
+    readonly type = "user";
+}
+export declare class ChannelOption extends OptionBuilder {
+    readonly type = "channel";
+}
+export declare class RoleOption extends OptionBuilder {
+    readonly type = "role";
+}
+type OptionInput<T> = T | ((option: T) => T);
+declare class OptionHolder extends Named {
+    protected plain: OptionBuilder[];
+    addStringOption(option: OptionInput<StringOption>): this;
+    addIntegerOption(option: OptionInput<IntegerOption>): this;
+    addNumberOption(option: OptionInput<NumberOption>): this;
+    addBooleanOption(option: OptionInput<BooleanOption>): this;
+    addUserOption(option: OptionInput<UserOption>): this;
+    addChannelOption(option: OptionInput<ChannelOption>): this;
+    addRoleOption(option: OptionInput<RoleOption>): this;
+}
+export declare class SubcommandBuilder extends OptionHolder {
+    toJSON(path?: string): APICommandOption;
+}
+export declare class SubcommandGroupBuilder extends Named {
+    private subcommands;
+    addSubcommand(sub: OptionInput<SubcommandBuilder>): this;
+    toJSON(path?: string): APICommandOption;
+}
+export declare class SlashCommandBuilder extends OptionHolder {
+    private nested;
+    addSubcommand(sub: OptionInput<SubcommandBuilder>): this;
+    addSubcommandGroup(group: OptionInput<SubcommandGroupBuilder>): this;
+    toJSON(): APICommand;
+}
+export declare class PrefixCommandBuilder extends Named {
+    private prefix?;
+    setPrefix(prefix: string): this;
+    toJSON(): APICommand;
+}
+export {};