chapterjs 0.1.1 → 0.1.4

package/dist/messages/translate.d.ts

@@ -0,0 +1,100 @@
+import { Locale } from '../discord/types/common.js';
+import type { Context } from '../structures/context.js';
+import type { Guild } from '../structures/guild.js';
+import type { MessageText, MessageTexts, PluralText, Translator } from './messages.js';
+/** A text, cut once: its literal parts and the placeholders between them. */
+export interface TextTemplate {
+    readonly text: string;
+    /** Odd entries are placeholder names, even ones literal text. */
+    readonly parts: readonly string[];
+    readonly params: readonly string[];
+}
+/** The forms of a plural, by name. */
+export type PluralForm = keyof PluralText;
+/** A text with several forms, one per quantity, picked by `count`. */
+export interface PluralTemplate {
+    readonly forms: ReadonlyMap<PluralForm, TextTemplate>;
+    /** `count`, then the placeholders of every form. */
+    readonly params: readonly string[];
+}
+export type Template = TextTemplate | PluralTemplate;
+/** The languages of `src/messages/`, checked and assembled: what `t` reads. */
+export interface LoadedMessages {
+    readonly default: Locale;
+    /** The texts of each language declared, compiled. */
+    readonly locales: ReadonlyMap<Locale, ReadonlyMap<string, Template>>;
+    /** The phrases of the framework each language translates, compiled. */
+    readonly framework: ReadonlyMap<Locale, ReadonlyMap<string, Template>>;
+    /**
+     * The `commands` section of each language that has one, by the path of
+     * the command file, not checked yet: the commands of the project are
+     * needed for that.
+     */
+    readonly commands: ReadonlyMap<Locale, Readonly<Record<string, unknown>>>;
+    /** The file of each language: `src/messages/fr.ts`. */
+    readonly files: ReadonlyMap<Locale, string>;
+}
+/** The forms a plural can have, in the order of the docs. */
+export declare const PLURAL_FORMS: readonly PluralForm[];
+/**
+ * Cuts a text around its placeholders, read from left to right: `{name}`
+ * is a placeholder, `{{` and `}}` are braces written as is, and a `{`
+ * with another `{` before its `}` is a brace too.
+ */
+export declare function compile(text: string): TextTemplate;
+/** Puts the forms of a plural together: `count` picks one when filled. */
+export declare function compilePlural(forms: ReadonlyMap<PluralForm, TextTemplate>): PluralTemplate;
+/** A text of a language file, trusted, compiled. */
+export declare function templateOf(text: MessageText): Template;
+/** Whether a template is a plural. */
+export declare const isPlural: (template: Template) => template is PluralTemplate;
+/** Every locale Discord knows. */
+export declare const LOCALES: ReadonlySet<string>;
+/**
+ * The language of the file to use for one asked: the same one, else one
+ * of the same language in another region (`en-GB` → `en-US`, `es-419` →
+ * `es-ES`, `zh-TW` → `zh-CN`), else the default.
+ */
+export declare function pickLocale(messages: LoadedMessages, locale: string | null): Locale;
+/**
+ * Fills the placeholders of a template, with an error naming a missing
+ * one. Numbers are written the way `locale` writes them, and a plural
+ * takes the form that language uses for `count`.
+ */
+export declare function fill(key: string, template: Template, params: Record<string, unknown> | undefined, locale?: string): string;
+/** `t` for one language of the file, the same object every time. */
+export declare function translatorFor(messages: LoadedMessages, locale: string | null): Translator<MessageTexts>;
+/** Who will read what is sent. */
+export interface Audience {
+    /** The language of the person (the one of an interaction), when known. */
+    person?: string | null | undefined;
+    /** The server the message goes to; `null` in private messages. */
+    guild?: Guild | null | undefined;
+    /** Whether the person alone sees it. */
+    ephemeral?: boolean | undefined;
+}
+/**
+ * The language of those who will read what is sent: the person when they
+ * alone see it (an ephemeral answer, a private message), else the language
+ * of the server when Discord knows it (it only does for Community servers:
+ * elsewhere `preferred_locale` is always `en-US`), else none, which means
+ * the default language of the file.
+ * @see https://docs.discord.com/developers/resources/guild#guild-object-guild-structure
+ */
+export declare function audienceLocale({ person, guild, ephemeral, }: Audience): string | null;
+/** A `t` for a project without a language in `src/messages/`: it says so when called. */
+export declare function missingTranslator(locale: string | null): Translator<MessageTexts>;
+/**
+ * `t` for what the bot sends, in the language of who will read it. Without
+ * a language, a `t` that explains it is missing when called: the
+ * texts of a component may still be functions of it.
+ */
+export declare function translatorOf(ctx: Pick<Context, 'messages'>, audience: Audience): Translator<MessageTexts>;
+/**
+ * What a handler receives about translations: `t` in the language asked
+ * when the project has a language in `src/messages/`, nothing otherwise. Spread it
+ * into the context of any handler.
+ */
+export declare function translation(ctx: Pick<Context, 'messages'>, locale: string | null): {
+    t?: Translator<MessageTexts>;
+};

package/dist/messages/translate.js

@@ -0,0 +1,249 @@
+// The runtime of `t`: which language to take, and a text with its
+// placeholders filled in. No dependency on the loader or on Discord.
+import { Locale } from '../discord/types/common.js';
+/** The forms a plural can have, in the order of the docs. */
+export const PLURAL_FORMS = [
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other',
+];
+/**
+ * Cuts a text around its placeholders, read from left to right: `{name}`
+ * is a placeholder, `{{` and `}}` are braces written as is, and a `{`
+ * with another `{` before its `}` is a brace too.
+ */
+export function compile(text) {
+    const parts = [];
+    const params = [];
+    let literal = '';
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === '{' && text[i + 1] === '{') {
+            literal += '{';
+            i += 2;
+        }
+        else if (char === '}' && text[i + 1] === '}') {
+            literal += '}';
+            i += 2;
+        }
+        else if (char === '{') {
+            const close = text.indexOf('}', i + 1);
+            const open = text.indexOf('{', i + 1);
+            if (close === -1 || (open !== -1 && open < close)) {
+                literal += '{';
+                i += 1;
+            }
+            else {
+                const name = text.slice(i + 1, close);
+                parts.push(literal, name);
+                if (!params.includes(name))
+                    params.push(name);
+                literal = '';
+                i = close + 1;
+            }
+        }
+        else {
+            literal += char;
+            i += 1;
+        }
+    }
+    parts.push(literal);
+    return { text, parts, params };
+}
+/** Puts the forms of a plural together: `count` picks one when filled. */
+export function compilePlural(forms) {
+    const params = ['count'];
+    for (const form of forms.values()) {
+        for (const name of form.params) {
+            if (!params.includes(name))
+                params.push(name);
+        }
+    }
+    return { forms, params };
+}
+/** A text of a language file, trusted, compiled. */
+export function templateOf(text) {
+    if (typeof text === 'string')
+        return compile(text);
+    return compilePlural(new Map(Object.entries(text).map(([form, one]) => [
+        form,
+        compile(one),
+    ])));
+}
+/** Whether a template is a plural. */
+export const isPlural = (template) => 'forms' in template;
+/** Every locale Discord knows. */
+export const LOCALES = new Set(Object.values(Locale));
+/**
+ * The language of the file to use for one asked: the same one, else one
+ * of the same language in another region (`en-GB` → `en-US`, `es-419` →
+ * `es-ES`, `zh-TW` → `zh-CN`), else the default.
+ */
+export function pickLocale(messages, locale) {
+    if (locale === null)
+        return messages.default;
+    if (messages.locales.has(locale))
+        return locale;
+    const language = locale.split('-')[0];
+    for (const known of messages.locales.keys()) {
+        if (known.split('-')[0] === language)
+            return known;
+    }
+    return messages.default;
+}
+const numberFormats = new Map();
+const pluralRules = new Map();
+/** How a language writes a number: `1,234` in English, `1 234` in French. */
+function numberFormat(locale) {
+    let format = numberFormats.get(locale);
+    if (!format) {
+        try {
+            format = new Intl.NumberFormat(locale);
+        }
+        catch {
+            format = new Intl.NumberFormat('en-US');
+        }
+        numberFormats.set(locale, format);
+    }
+    return format;
+}
+/** Which form of a plural a language uses for a number. */
+function pluralRule(locale) {
+    let rules = pluralRules.get(locale);
+    if (!rules) {
+        try {
+            rules = new Intl.PluralRules(locale);
+        }
+        catch {
+            rules = new Intl.PluralRules('en-US');
+        }
+        pluralRules.set(locale, rules);
+    }
+    return rules;
+}
+/** A value where a placeholder is: a number the way the language writes it. */
+const show = (value, locale) => typeof value === 'number'
+    ? numberFormat(locale).format(value)
+    : String(value);
+/**
+ * Fills the placeholders of a template, with an error naming a missing
+ * one. Numbers are written the way `locale` writes them, and a plural
+ * takes the form that language uses for `count`.
+ */
+export function fill(key, template, params, locale = 'en-US') {
+    if (template.params.length === 0)
+        return template.text;
+    const missing = template.params.filter(name => params?.[name] === undefined);
+    if (missing.length > 0) {
+        throw new TypeError(`The message "${key}" needs ${missing.map(name => `{${name}}`).join(', ')}: t('${key}', { ${template.params.join(', ')} })`);
+    }
+    if (isPlural(template)) {
+        const count = params.count;
+        if (typeof count !== 'number') {
+            throw new TypeError(`The message "${key}" is a plural: its {count} is a number, got ${JSON.stringify(count)}.`);
+        }
+        const form = pluralRule(locale).select(count);
+        template = template.forms.get(form) ?? template.forms.get('other');
+    }
+    let text = '';
+    template.parts.forEach((part, index) => {
+        text += index % 2 === 0 ? part : show(params[part], locale);
+    });
+    return text;
+}
+/** The `t` of each language asked, made once per set of messages. */
+const translators = new WeakMap();
+/** `t` for one language of the file, the same object every time. */
+export function translatorFor(messages, locale) {
+    let made = translators.get(messages);
+    if (!made)
+        translators.set(messages, (made = new Map()));
+    const asked = locale ?? '';
+    const known = made.get(asked);
+    if (known)
+        return known;
+    const picked = pickLocale(messages, locale);
+    const texts = messages.locales.get(picked);
+    // A text the language does not have is the default language's.
+    const base = messages.locales.get(messages.default);
+    const t = ((key, params) => {
+        const own = texts.get(key);
+        if (own)
+            return fill(key, own, params, picked);
+        const template = base.get(key);
+        if (!template) {
+            throw new TypeError(`There is no message "${key}" in src/messages/. It has: ${[...base.keys()].join(', ')}.`);
+        }
+        return fill(key, template, params, messages.default);
+    });
+    Object.defineProperties(t, {
+        locale: { value: picked, enumerable: true },
+        in: {
+            // `t.in('fr')` is a `t`, `t.in('fr', 'welcome', { name })` a text.
+            value: (other, key, params) => key === undefined
+                ? translatorFor(messages, other)
+                : translatorFor(messages, other)(key, params),
+            enumerable: false,
+        },
+    });
+    Object.freeze(t);
+    made.set(asked, t);
+    return t;
+}
+/**
+ * The language of those who will read what is sent: the person when they
+ * alone see it (an ephemeral answer, a private message), else the language
+ * of the server when Discord knows it (it only does for Community servers:
+ * elsewhere `preferred_locale` is always `en-US`), else none, which means
+ * the default language of the file.
+ * @see https://docs.discord.com/developers/resources/guild#guild-object-guild-structure
+ */
+export function audienceLocale({ person, guild, ephemeral, }) {
+    if (ephemeral || !guild)
+        return person ?? null;
+    return guild.features.includes('COMMUNITY') ? guild.preferredLocale : null;
+}
+const missing = new Map();
+/** A `t` for a project without a language in `src/messages/`: it says so when called. */
+export function missingTranslator(locale) {
+    const shown = locale ?? 'en-US';
+    const known = missing.get(shown);
+    if (known)
+        return known;
+    const t = (() => {
+        throw new TypeError('This project has no language in src/messages/: add one, like src/messages/en-US.ts, to use t().');
+    });
+    Object.defineProperties(t, {
+        locale: { value: shown, enumerable: true },
+        in: {
+            value: (_other, key) => key === undefined ? t : t(),
+            enumerable: false,
+        },
+    });
+    Object.freeze(t);
+    missing.set(shown, t);
+    return t;
+}
+/**
+ * `t` for what the bot sends, in the language of who will read it. Without
+ * a language, a `t` that explains it is missing when called: the
+ * texts of a component may still be functions of it.
+ */
+export function translatorOf(ctx, audience) {
+    const locale = audienceLocale(audience);
+    return ctx.messages
+        ? translatorFor(ctx.messages, locale)
+        : missingTranslator(locale);
+}
+/**
+ * What a handler receives about translations: `t` in the language asked
+ * when the project has a language in `src/messages/`, nothing otherwise. Spread it
+ * into the context of any handler.
+ */
+export function translation(ctx, locale) {
+    return ctx.messages ? { t: translatorFor(ctx.messages, locale) } : {};
+}

package/dist/presence/convention.d.ts

@@ -0,0 +1,26 @@
+import type { Convention } from '../loader/loader.js';
+import { type RawGatewayPresenceUpdate } from '../discord/types/gateway-events.js';
+/** The presence file, checked: what the gateway sends. */
+export interface LoadedPresence {
+    /** The Update Presence payload (also sent with Identify). */
+    readonly raw: RawGatewayPresenceUpdate;
+    /** What tells one presence from another: the payload, as text. */
+    readonly key: string;
+}
+/**
+ * What a bot without a presence file shows: online, doing nothing. Sent
+ * when the file is removed while the bot runs.
+ */
+export declare const DEFAULT_PRESENCE: RawGatewayPresenceUpdate;
+/**
+ * `src/presence.ts`: the status of the bot and what it is doing. The file
+ * exports by default what `presence()` returns:
+ *
+ * ```ts
+ * // src/presence.ts
+ * import { presence } from 'chapterjs';
+ *
+ * export default presence({ activity: { type: 'playing', name: '/help' } });
+ * ```
+ */
+export declare const presenceConvention: Convention<LoadedPresence>;

package/dist/presence/convention.js

@@ -0,0 +1,133 @@
+// `src/presence.ts`: the one file that says what the bot shows under its
+// name. What it declares is checked when it loads and turned into what the
+// gateway sends, so a wrong status or type is explained before the bot
+// connects.
+import { ActivityType, } from '../discord/types/gateway-events.js';
+import { isPresenceFile } from './presence.js';
+const fail = message => {
+    throw new TypeError(message);
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const KEYS = ['status', 'activity'];
+const ACTIVITY_KEYS = ['type', 'name', 'url'];
+/**
+ * The statuses a file may give.
+ * @see https://docs.discord.com/developers/events/gateway-events#update-presence-status-types
+ */
+const STATUSES = ['online', 'idle', 'dnd', 'invisible'];
+/**
+ * The activity types, by the word a file writes.
+ * @see https://docs.discord.com/developers/events/gateway-events#activity-object-activity-types
+ */
+const TYPES = {
+    playing: ActivityType.Playing,
+    streaming: ActivityType.Streaming,
+    listening: ActivityType.Listening,
+    watching: ActivityType.Watching,
+    custom: ActivityType.Custom,
+    competing: ActivityType.Competing,
+};
+/**
+ * "The streaming type currently only supports Twitch and YouTube. Only
+ * https://twitch.tv/ and https://youtube.com/ urls will work."
+ * @see https://docs.discord.com/developers/events/gateway-events#activity-object-activity-types
+ */
+const STREAM_URL = /^https:\/\/(?:www\.)?(?:twitch\.tv|youtube\.com)\//;
+const list = (words) => words.map(word => `'${word}'`).join(', ');
+const EXAMPLE = `presence({ status: 'online', activity: { type: 'watching', name: 'over the server' } })`;
+/**
+ * What a bot without a presence file shows: online, doing nothing. Sent
+ * when the file is removed while the bot runs.
+ */
+export const DEFAULT_PRESENCE = Object.freeze({
+    since: null,
+    activities: [],
+    status: 'online',
+    afk: false,
+});
+/** Turns a checked config into what the gateway sends. */
+function toRaw(config) {
+    const activities = [];
+    if (config.activity) {
+        const { type, name, url } = config.activity;
+        activities.push(type === 'custom'
+            ? // A custom status shows its `state`; `name` is not shown but required.
+                { name: 'Custom Status', type: TYPES.custom, state: name }
+            : { name, type: TYPES[type], ...(url ? { url } : {}) });
+    }
+    // `since` and `afk` are about a person's client going idle: a bot is
+    // never away from its keyboard.
+    return {
+        since: null,
+        activities,
+        status: config.status ?? 'online',
+        afk: false,
+    };
+}
+/**
+ * `src/presence.ts`: the status of the bot and what it is doing. The file
+ * exports by default what `presence()` returns:
+ *
+ * ```ts
+ * // src/presence.ts
+ * import { presence } from 'chapterjs';
+ *
+ * export default presence({ activity: { type: 'playing', name: '/help' } });
+ * ```
+ */
+export const presenceConvention = {
+    folder: 'presence',
+    single: true,
+    one: 'presence',
+    many: 'presences',
+    read(exports) {
+        const file = exports.default;
+        const example = `import { presence } from 'chapterjs'; export default ${EXAMPLE}`;
+        if (!isPresenceFile(file)) {
+            return fail('default' in exports
+                ? `The default export of this file must be what presence() returns: ${example}`
+                : `This file has no default export. It should look like: ${example}`);
+        }
+        const config = file.config;
+        if (!isRecord(config)) {
+            return fail(`presence() needs an object: ${EXAMPLE}`);
+        }
+        for (const key of Object.keys(config)) {
+            if (!KEYS.includes(key)) {
+                fail(`"${key}" is not something a presence has. It can have: ${KEYS.join(', ')}.`);
+            }
+        }
+        const { status, activity } = config;
+        if (status !== undefined &&
+            !STATUSES.includes(status)) {
+            fail(`"status" is ${JSON.stringify(status)}: it can be ${list(STATUSES)}.`);
+        }
+        if (activity !== undefined) {
+            if (!isRecord(activity)) {
+                fail(`"activity" is what the bot is doing, an object: activity: { type: 'playing', name: '/help' }`);
+            }
+            for (const key of Object.keys(activity)) {
+                if (!ACTIVITY_KEYS.includes(key)) {
+                    fail(`"${key}" is not something an activity has. It can have: ${ACTIVITY_KEYS.join(', ')}.`);
+                }
+            }
+            const { type, name, url } = activity;
+            if (typeof type !== 'string' || !(type in TYPES)) {
+                fail(`The "type" of the activity is ${JSON.stringify(type)}: it can be ${list(Object.keys(TYPES))}.`);
+            }
+            if (typeof name !== 'string' || name.trim() === '') {
+                fail(`The "name" of the activity is the text shown under the name of the bot: it can't be empty.`);
+            }
+            if (type === 'streaming') {
+                if (typeof url !== 'string' || !STREAM_URL.test(url)) {
+                    fail(`A "streaming" activity needs the "url" of the stream, and Discord only accepts a https://twitch.tv/ or a https://youtube.com/ link${typeof url === 'string' ? ` (got ${JSON.stringify(url)})` : ''}.`);
+                }
+            }
+            else if (url !== undefined) {
+                fail(`"url" only goes with a "streaming" activity: a ${JSON.stringify(type)} activity has no link.`);
+            }
+        }
+        const raw = toRaw(config);
+        return { raw, key: JSON.stringify(raw) };
+    },
+};

package/dist/presence/presence.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The status of the bot: `'online'` (green), `'idle'` (orange), `'dnd'`
+ * (red, "do not disturb") or `'invisible'` (shown as offline).
+ */
+export type PresenceStatusName = 'online' | 'idle' | 'dnd' | 'invisible';
+/**
+ * What the bot is doing, as Discord shows it: "Playing {name}",
+ * "Listening to {name}", "Watching {name}", "Competing in {name}", or
+ * the text itself with `'custom'`.
+ */
+export type ActivityKind = 'playing' | 'listening' | 'watching' | 'competing' | 'custom';
+/** An activity that is not a stream. */
+export interface PlainActivity {
+    type: ActivityKind;
+    /** What is shown after the type (or alone with `'custom'`). */
+    name: string;
+    url?: never;
+}
+/** A stream: "Streaming {name}", with a link to it. */
+export interface StreamingActivity {
+    type: 'streaming';
+    /** What is shown after "Streaming". */
+    name: string;
+    /** The stream: Discord only accepts a `https://twitch.tv/` or a `https://youtube.com/` link. */
+    url: string;
+}
+/** What the bot is doing. */
+export type Activity = PlainActivity | StreamingActivity;
+/** What `src/presence.ts` gives to `presence()`. */
+export interface PresenceConfig {
+    /** The status of the bot. `'online'` by default. */
+    status?: PresenceStatusName;
+    /** What the bot is doing. Nothing by default. */
+    activity?: Activity;
+}
+/** What `presence()` returns: the default export of `src/presence.ts`. */
+export interface PresenceFile {
+    /** What the file gave to `presence()`, not checked yet. */
+    readonly config: unknown;
+}
+/**
+ * Declares the presence of the bot: its status and what it is doing, shown
+ * under its name. Export the result as the default export of
+ * `src/presence.ts`; the bot has it as soon as it is connected.
+ *
+ * ```ts
+ * import { presence } from 'chapterjs';
+ *
+ * export default presence({
+ *   status: 'online',
+ *   activity: { type: 'watching', name: 'over the server' },
+ * });
+ * ```
+ */
+export declare function presence(config: PresenceConfig): PresenceFile;
+/** Whether a value was made by `presence()`. */
+export declare function isPresenceFile(value: unknown): value is PresenceFile;

package/dist/presence/presence.js

@@ -0,0 +1,27 @@
+// `presence()`, as `src/presence.ts` imports it from 'chapterjs': what the
+// bot shows under its name, its status and what it is doing.
+// https://docs.discord.com/developers/events/gateway-events#update-presence
+const BRAND = Symbol.for('chapterjs.presence');
+/**
+ * Declares the presence of the bot: its status and what it is doing, shown
+ * under its name. Export the result as the default export of
+ * `src/presence.ts`; the bot has it as soon as it is connected.
+ *
+ * ```ts
+ * import { presence } from 'chapterjs';
+ *
+ * export default presence({
+ *   status: 'online',
+ *   activity: { type: 'watching', name: 'over the server' },
+ * });
+ * ```
+ */
+export function presence(config) {
+    return Object.freeze({ [BRAND]: true, config });
+}
+/** Whether a value was made by `presence()`. */
+export function isPresenceFile(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[BRAND] === true);
+}

package/dist/rest/errors.d.ts

@@ -0,0 +1,55 @@
+import type { HttpMethod } from '../discord/endpoint.js';
+/** One problem Discord found in a field of the request. */
+export interface DiscordFieldError {
+    /** Where the problem is: `embeds[0].title`, or `` for the whole request. */
+    path: string;
+    /** The kind of problem, as Discord names it (`BASE_TYPE_MAX_LENGTH`). */
+    code: string;
+    /** What is wrong, in English. */
+    message: string;
+}
+/**
+ * Turns the nested `errors` object of an error response into a flat list.
+ * A problem is an `_errors` array placed under the key of the field, at any
+ * depth; array items are keyed by their index.
+ * @see https://docs.discord.com/developers/reference#error-messages
+ */
+export declare function flattenFieldErrors(errors: unknown, path?: string): DiscordFieldError[];
+/** Discord answered a request with an error. */
+export declare class DiscordApiError extends Error {
+    readonly name = "DiscordApiError";
+    /** The HTTP status of the response (403, 404...). */
+    readonly status: number;
+    /**
+     * The JSON error code of Discord (50013 for "Missing Permissions"...), or
+     * 0 when the response had none.
+     * @see https://docs.discord.com/developers/topics/opcodes-and-status-codes#json-json-error-codes
+     */
+    readonly code: number;
+    /** The fields of the request Discord refused, when it says which. */
+    readonly fieldErrors: readonly DiscordFieldError[];
+    /** The HTTP method of the request that failed. */
+    readonly method: HttpMethod;
+    /** The path of the endpoint as written in the documentation. */
+    readonly route: string;
+    constructor(input: {
+        status: number;
+        method: HttpMethod;
+        route: string;
+        body: unknown;
+    });
+}
+/** A request could not reach Discord, or Discord kept failing. */
+export declare class DiscordUnavailableError extends Error {
+    readonly name = "DiscordUnavailableError";
+    /** The HTTP method of the request that failed. */
+    readonly method: HttpMethod;
+    /** The path of the endpoint as written in the documentation. */
+    readonly route: string;
+    constructor(method: HttpMethod, route: string, cause: unknown);
+}
+/** The bot token was refused: no request can succeed until it is fixed. */
+export declare class InvalidTokenError extends Error {
+    readonly name = "InvalidTokenError";
+    constructor();
+}