chapterjs 0.1.2 → 0.2.0

package/dist/components/modal.js

@@ -0,0 +1,398 @@
+// `modal()`, as the files of `src/components/modals/` import it from
+// 'chapterjs': a form that opens in Discord, its fields typed in `run`.
+// https://docs.discord.com/developers/components/using-modal-components
+import { Limits } from '../discord/api.js';
+import { ComponentType, TextInputStyle, } from '../discord/types/component.js';
+import { isDynamic, resolveText, } from './component.js';
+import { checkData, encodeCustomId, } from './custom-id.js';
+import { createComponent } from './declared.js';
+import { hasDynamicOption, readOptions, resolveOptions, } from './options.js';
+import { readChannelTypes, readPlaceholder, readRange, SELECT_TYPES, } from './select.js';
+/**
+ * Declares a form. Export the result from any file of `src/`: the name of
+ * the export is what tells the form apart, so you never write an id.
+ *
+ * ```ts
+ * import { modal } from 'chapterjs';
+ *
+ * export const feedback = modal({
+ *   title: 'Feedback',
+ *   fields: {
+ *     text: { type: 'text', label: 'What do you think?', style: 'paragraph' },
+ *   },
+ *   async run({ interaction, fields }) {
+ *     await interaction.reply({ content: `Thanks! You wrote: ${fields.text}`, ephemeral: true });
+ *   },
+ * });
+ * ```
+ */
+export function modal(config) {
+    return createComponent('modal', config, {
+        asPiece: true,
+        pieceKind: 'modal',
+    });
+}
+const fail = (message) => {
+    throw new TypeError(message);
+};
+const FIELD_TYPES = [
+    'text',
+    'select',
+    'user',
+    'role',
+    'mentionable',
+    'channel',
+    'files',
+    'radio',
+    'checkboxes',
+    'checkbox',
+    'note',
+];
+/** The keys each kind of field accepts. */
+const FIELD_KEYS = {
+    text: ['style', 'placeholder', 'required', 'minLength', 'maxLength', 'value'],
+    select: ['options', 'placeholder', 'min', 'max', 'required'],
+    user: ['placeholder', 'min', 'max', 'required'],
+    role: ['placeholder', 'min', 'max', 'required'],
+    mentionable: ['placeholder', 'min', 'max', 'required'],
+    channel: ['placeholder', 'min', 'max', 'required', 'channelTypes'],
+    files: ['min', 'max', 'required', 'fileTypes'],
+    radio: ['options', 'required'],
+    checkboxes: ['options', 'min', 'max', 'required'],
+    checkbox: ['default'],
+    note: ['content'],
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function checkText(what, value, max, { required = true, min = 1 } = {}) {
+    if (value === undefined)
+        return required ? fail(`${what} is missing.`) : undefined;
+    // A function is checked when the form opens.
+    if (isDynamic(value))
+        return undefined;
+    if (typeof value !== 'string')
+        return fail(`${what} is a text, got ${typeof value}.`);
+    if (value.length < min || value.length > max) {
+        return fail(`${what} is ${value.length} characters long: Discord accepts between ${min} and ${max}.`);
+    }
+    return value;
+}
+function checkBoolean(what, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'boolean')
+        return fail(`${what} is true or false, got ${JSON.stringify(value) ?? typeof value}.`);
+    return value;
+}
+/** Checks one field of a form. */
+export function readField(name, given) {
+    const what = `the field "${name}"`;
+    if (!/^[A-Za-z_$][\w$]*$/.test(name)) {
+        fail(`"${name}" can't be the name of a field: it is how your code reads it (fields.${name}), so use letters, digits and _ only.`);
+    }
+    if (!isRecord(given)) {
+        return fail(`${what} must be an object like { type: 'text', label: '...' }.`);
+    }
+    const type = given.type;
+    if (!FIELD_TYPES.includes(type)) {
+        fail(`The type of ${what} is ${JSON.stringify(given.type)}, which does not exist. Types are: ${FIELD_TYPES.join(', ')}.`);
+    }
+    for (const key of Object.keys(given)) {
+        const allowed = [
+            'type',
+            ...(type === 'note' ? [] : ['label', 'description']),
+            ...FIELD_KEYS[type],
+        ];
+        if (!allowed.includes(key)) {
+            fail(`"${key}" is not something ${what} has (a ${type}). It can have: ${allowed.join(', ')}.`);
+        }
+    }
+    if (type === 'note') {
+        checkText(`The content of ${what}`, given.content, Limits.TextDisplayTotal);
+        return {
+            name,
+            field: given,
+            options: [],
+            required: false,
+            min: 0,
+            max: 0,
+        };
+    }
+    checkText(`The label of ${what}`, given.label, Limits.LabelText);
+    checkText(`The description of ${what}`, given.description, Limits.LabelDescription, { required: false });
+    const required = checkBoolean(`"required" of ${what}`, given.required, true);
+    let options = [];
+    let range = { min: 1, max: 1 };
+    switch (type) {
+        case 'text': {
+            if (given.style !== undefined &&
+                given.style !== 'short' &&
+                given.style !== 'paragraph') {
+                fail(`The style of ${what} is 'short' or 'paragraph', got ${JSON.stringify(given.style)}.`);
+            }
+            checkText(`The placeholder of ${what}`, given.placeholder, Limits.TextInputPlaceholder, { required: false });
+            checkText(`The value of ${what}`, given.value, Limits.TextInputLength, {
+                required: false,
+                min: 0,
+            });
+            range = readRange(what, { min: given.minLength, max: given.maxLength }, Limits.TextInputLength, { min: 0, max: Limits.TextInputLength });
+            break;
+        }
+        case 'select':
+            options = readOptions(what, given.options);
+            readPlaceholder(what, given.placeholder);
+            range = readRange(what, given, Limits.SelectValues, { min: 1, max: 1 });
+            break;
+        case 'user':
+        case 'role':
+        case 'mentionable':
+        case 'channel':
+            readPlaceholder(what, given.placeholder);
+            range = readRange(what, given, Limits.SelectValues, { min: 1, max: 1 });
+            if (type === 'channel')
+                readChannelTypes(what, given.channelTypes);
+            break;
+        case 'files':
+            range = readRange(what, given, Limits.FileUploadMax, { min: 1, max: 1 });
+            if (given.fileTypes !== undefined) {
+                const types = given.fileTypes;
+                if (!Array.isArray(types) ||
+                    types.length === 0 ||
+                    types.length > Limits.FileUploadTypes ||
+                    !types.every(one => typeof one === 'string' &&
+                        /^(image|video|audio|\.[\w-]+)$/.test(one))) {
+                    fail(`"fileTypes" of ${what} is a list of 'image', 'video', 'audio' or extensions like '.pdf' (${Limits.FileUploadTypes} at most).`);
+                }
+            }
+            break;
+        case 'radio':
+            options = readOptions(what, given.options, {
+                min: Limits.RadioOptionsMin,
+                max: Limits.RadioOptions,
+            });
+            break;
+        case 'checkboxes':
+            options = readOptions(what, given.options, {
+                min: 1,
+                max: Limits.CheckboxOptions,
+            });
+            range = readRange(what, given, Limits.CheckboxOptions, {
+                min: 1,
+                max: options.length,
+            });
+            if (range.max > options.length) {
+                fail(`"max" of ${what} is ${range.max}, but it only has ${options.length} options.`);
+            }
+            break;
+        case 'checkbox':
+            checkBoolean(`"default" of ${what}`, given.default, false);
+            break;
+    }
+    return {
+        name,
+        field: given,
+        options,
+        required,
+        ...range,
+    };
+}
+/** The label and the input of one field, as Discord takes them. */
+function renderField(loaded, prefill, context) {
+    const { name, field, required, min, max } = loaded;
+    const what = `the field "${name}"`;
+    if (field.type === 'note') {
+        return {
+            type: ComponentType.TextDisplay,
+            content: resolveText(`The content of ${what}`, field.content, context, {
+                max: Limits.TextDisplayTotal,
+            }),
+        };
+    }
+    const placeholder = 'placeholder' in field
+        ? resolveText(`The placeholder of ${what}`, field.placeholder, context, {
+            max: field.type === 'text'
+                ? Limits.TextInputPlaceholder
+                : Limits.SelectPlaceholder,
+        })
+        : undefined;
+    const options = resolveOptions(what, loaded.options, context);
+    const base = { custom_id: name };
+    const picked = Array.isArray(prefill)
+        ? prefill
+        : prefill !== undefined
+            ? [prefill]
+            : undefined;
+    const withDefaults = (options) => options.map(option => {
+        const { default: initial, ...rest } = option;
+        const isDefault = picked ? picked.includes(option.value) : initial;
+        return isDefault ? { ...rest, default: true } : rest;
+    });
+    let component;
+    switch (field.type) {
+        case 'text':
+            component = {
+                type: ComponentType.TextInput,
+                ...base,
+                style: field.style === 'paragraph'
+                    ? TextInputStyle.Paragraph
+                    : TextInputStyle.Short,
+                ...(min !== 0 ? { min_length: min } : {}),
+                ...(max !== Limits.TextInputLength ? { max_length: max } : {}),
+                ...(required ? {} : { required: false }),
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                ...((prefill ?? field.value) !== undefined
+                    ? { value: (prefill ?? field.value) }
+                    : {}),
+            };
+            break;
+        case 'select':
+            component = {
+                type: ComponentType.StringSelect,
+                ...base,
+                options: withDefaults(options),
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                ...(min !== 1 ? { min_values: min } : {}),
+                ...(max !== 1 ? { max_values: max } : {}),
+                ...(required ? {} : { required: false }),
+            };
+            break;
+        case 'user':
+        case 'role':
+        case 'mentionable':
+        case 'channel':
+            component = {
+                type: SELECT_TYPES[field.type],
+                ...base,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                ...(min !== 1 ? { min_values: min } : {}),
+                ...(max !== 1 ? { max_values: max } : {}),
+                ...(required ? {} : { required: false }),
+                ...(field.type === 'channel' && field.channelTypes
+                    ? { channel_types: [...field.channelTypes] }
+                    : {}),
+            };
+            break;
+        case 'files':
+            component = {
+                type: ComponentType.FileUpload,
+                ...base,
+                ...(min !== 1 ? { min_values: min } : {}),
+                ...(max !== 1 ? { max_values: max } : {}),
+                ...(required ? {} : { required: false }),
+                ...(field.fileTypes ? { file_types: [...field.fileTypes] } : {}),
+            };
+            break;
+        case 'radio':
+            component = {
+                type: ComponentType.RadioGroup,
+                ...base,
+                options: withDefaults(options),
+                ...(required ? {} : { required: false }),
+            };
+            break;
+        case 'checkboxes':
+            component = {
+                type: ComponentType.CheckboxGroup,
+                ...base,
+                options: withDefaults(options),
+                ...(min !== 1 ? { min_values: min } : {}),
+                ...(max !== loaded.options.length ? { max_values: max } : {}),
+                ...(required ? {} : { required: false }),
+            };
+            break;
+        case 'checkbox': {
+            const checked = prefill !== undefined ? prefill === true : field.default === true;
+            component = {
+                type: ComponentType.Checkbox,
+                ...base,
+                ...(checked ? { default: true } : {}),
+            };
+            break;
+        }
+    }
+    const description = resolveText(`The description of ${what}`, field.description, context, { max: Limits.LabelDescription });
+    return {
+        type: ComponentType.Label,
+        label: resolveText(`The label of ${what}`, field.label, context, {
+            max: Limits.LabelText,
+        }),
+        ...(description !== undefined ? { description } : {}),
+        component,
+    };
+}
+/** Checks what a form is opened with. */
+function readPrefill(loaded, name, given) {
+    if (given === undefined)
+        return {};
+    if (!isRecord(given))
+        fail(`The options of ${name} are an object like { values: { ... } }.`);
+    const options = given;
+    for (const key of Object.keys(options)) {
+        if (key !== 'values')
+            fail(`"${key}" is not something ${name} takes when opened. It can take: values.`);
+    }
+    if (options.values === undefined)
+        return {};
+    if (!isRecord(options.values))
+        fail(`"values" of ${name} is an object whose keys are the names of its fields.`);
+    const values = options.values;
+    for (const [key, value] of Object.entries(values)) {
+        const field = loaded.fields.find(one => one.name === key);
+        if (!field)
+            fail(`"${key}" is not a field of ${name}. Its fields are: ${loaded.fields.map(one => one.name).join(', ')}.`);
+        const { type } = field.field;
+        const bad = (expected) => fail(`The value given for the field "${key}" of ${name} is ${expected}, got ${JSON.stringify(value) ?? typeof value}.`);
+        const known = (picked) => {
+            if (!field.options.some(option => option.value === picked)) {
+                fail(`${JSON.stringify(picked)} is not an option of the field "${key}" of ${name}. Its options are: ${field.options.map(option => option.value).join(', ')}.`);
+            }
+        };
+        switch (type) {
+            case 'text':
+                if (typeof value !== 'string' || value.length > Limits.TextInputLength)
+                    bad(`a text of ${Limits.TextInputLength} characters at most`);
+                break;
+            case 'select':
+            case 'checkboxes':
+                if (!Array.isArray(value))
+                    bad('a list of its options');
+                value.forEach(known);
+                break;
+            case 'radio':
+                known(value);
+                break;
+            case 'checkbox':
+                if (typeof value !== 'boolean')
+                    bad('true or false');
+                break;
+            default:
+                fail(`The field "${key}" of ${name} is a ${type}: it can't be given a value when the form opens.`);
+        }
+    }
+    return values;
+}
+/** The form as Discord takes it, for the data and the values given. */
+export function renderModal(loaded, args) {
+    const hasData = Object.keys(loaded.data).length > 0;
+    const { name } = loaded;
+    if (args.length > (hasData ? 2 : 1)) {
+        fail(`${name} takes ${hasData ? 'its data, then options' : 'options'} at most.`);
+    }
+    const values = checkData(name, loaded.data, hasData ? args[0] : undefined);
+    const prefill = readPrefill(loaded, name, hasData ? args[1] : args[0]);
+    const make = (context) => ({
+        custom_id: encodeCustomId(loaded.name, loaded.data, values),
+        title: resolveText(`The title of ${name}`, loaded.title, context, {
+            max: Limits.ModalTitle,
+        }),
+        components: loaded.fields.map(field => renderField(field, prefill[field.name], context)),
+    });
+    // Texts computed when the form opens wait for the language of the person.
+    const dynamic = isDynamic(loaded.title) ||
+        loaded.fields.some(({ field, options }) => Object.values(field).some(isDynamic) || hasDynamicOption(options));
+    return {
+        kind: 'modal',
+        raw: dynamic
+            ? t => make({ t, data: values })
+            : make({ t: undefined, data: values }),
+    };
+}

package/dist/components/options.d.ts

@@ -0,0 +1,41 @@
+import type { RawSelectOption } from '../discord/types/component.js';
+import type { EmojiInput } from '../structures/message.js';
+import type { DataShape } from './custom-id.js';
+import { type DynamicText, type TextContext } from './component.js';
+/** One option of a menu, with everything Discord shows for it. */
+export interface RichOption<Data extends DataShape = DataShape> {
+    /** What the person sees (100 characters at most): a text, or a function of `t` and the data. */
+    label: DynamicText<Data>;
+    /** What your code receives (100 characters at most). */
+    value: string;
+    /** A second line under the label (100 characters at most): a text, or a function of `t` and the data. */
+    description?: DynamicText<Data>;
+    /** An emoji before the label. */
+    emoji?: EmojiInput;
+    /** Shows the option as picked when the menu appears. */
+    default?: boolean;
+}
+/**
+ * The options of a menu: a list of texts (each is shown and received as
+ * is), an object whose keys are what is shown and values what your code
+ * receives, or a list of `RichOption` for descriptions and emojis.
+ */
+export type SelectOptions<Data extends DataShape = DataShape> = readonly string[] | Readonly<Record<string, string>> | readonly RichOption<Data>[];
+/** An option as a file declared it, its texts maybe computed when sent. */
+export type LoadedOption = Omit<RawSelectOption, 'label' | 'description'> & {
+    label: DynamicText;
+    description?: DynamicText;
+};
+/** The options as Discord takes them, their texts computed for who reads. */
+export declare function resolveOptions(what: string, options: readonly LoadedOption[], context: TextContext): RawSelectOption[];
+/** Whether a text of an option is computed when the message is sent. */
+export declare const hasDynamicOption: (options: readonly LoadedOption[]) => boolean;
+/** What `run` receives for one picked option, typed from the declaration. */
+export type OptionValue<Options extends SelectOptions> = Options extends readonly (infer Item)[] ? Item extends string ? Item : Item extends {
+    value: infer Value extends string;
+} ? Value : never : Options extends Readonly<Record<string, infer Value extends string>> ? Value : never;
+/** Checks the options of a menu and returns them as Discord takes them. */
+export declare function readOptions(what: string, options: unknown, { min, max }?: {
+    min?: number;
+    max?: number;
+}): LoadedOption[];

package/dist/components/options.js

@@ -0,0 +1,101 @@
+// The options of a select menu, a radio group or a checkbox group, as files
+// declare them: a list of texts, an object from what is shown to what the
+// code receives, or a list of objects with a description and an emoji.
+// Written once for the three.
+import { Limits } from '../discord/api.js';
+import { emojiOf } from './instance.js';
+import { isDynamic, resolveText, } from './component.js';
+/** The options as Discord takes them, their texts computed for who reads. */
+export function resolveOptions(what, options, context) {
+    return options.map((option, index) => {
+        const { label, description, ...rest } = option;
+        const resolved = resolveText(`The label of option ${index + 1} of ${what}`, label, context, { max: Limits.SelectOptionText });
+        const second = resolveText(`The description of option ${index + 1} of ${what}`, description, context, { max: Limits.SelectOptionText });
+        return {
+            ...rest,
+            label: resolved,
+            ...(second !== undefined ? { description: second } : {}),
+        };
+    });
+}
+/** Whether a text of an option is computed when the message is sent. */
+export const hasDynamicOption = (options) => options.some(option => isDynamic(option.label) || isDynamic(option.description));
+const fail = (message) => {
+    throw new TypeError(message);
+};
+/** Checks the options of a menu and returns them as Discord takes them. */
+export function readOptions(what, options, { min = 1, max = Limits.SelectOptions } = {}) {
+    const example = `options: ['Pizza', 'Pasta'], options: { 'Shown text': 'value' } or options: [{ label: '...', value: '...', description: '...' }]`;
+    let list;
+    if (Array.isArray(options)) {
+        list = options.map((item, index) => {
+            if (typeof item === 'string')
+                return { label: item, value: item };
+            if (typeof item !== 'object' || item === null) {
+                return fail(`Option ${index + 1} of ${what} is a text or an object like { label: '...', value: '...' }, got ${item === null ? 'null' : typeof item}.`);
+            }
+            const rich = item;
+            for (const key of Object.keys(rich)) {
+                if (!['label', 'value', 'description', 'emoji', 'default'].includes(key)) {
+                    fail(`"${key}" is not something an option of ${what} has. It can have: label, value, description, emoji, default.`);
+                }
+            }
+            if ((typeof rich.label !== 'string' && !isDynamic(rich.label)) ||
+                typeof rich.value !== 'string') {
+                fail(`Option ${index + 1} of ${what} needs a label and a value, both texts.`);
+            }
+            const option = {
+                label: rich.label,
+                value: rich.value,
+            };
+            if (rich.description !== undefined) {
+                if (typeof rich.description !== 'string' &&
+                    !isDynamic(rich.description))
+                    fail(`The description of option ${index + 1} of ${what} is a text.`);
+                option.description = rich.description;
+            }
+            if (rich.emoji !== undefined)
+                option.emoji = emojiOf(rich.emoji, `option ${index + 1} of ${what}`);
+            if (rich.default !== undefined) {
+                if (typeof rich.default !== 'boolean')
+                    fail(`"default" of option ${index + 1} of ${what} is true or false.`);
+                if (rich.default)
+                    option.default = true;
+            }
+            return option;
+        });
+    }
+    else if (typeof options === 'object' && options !== null) {
+        list = Object.entries(options).map(([label, value]) => {
+            if (typeof value !== 'string') {
+                return fail(`The option ${JSON.stringify(label)} of ${what} must be a text (what your code receives), got ${JSON.stringify(value) ?? typeof value}.`);
+            }
+            return { label, value };
+        });
+    }
+    else {
+        return fail(`${what} needs its options: ${example}.`);
+    }
+    if (list.length < min || list.length > max) {
+        fail(`${what} has ${list.length} options: Discord accepts between ${min} and ${max}.`);
+    }
+    const values = new Set();
+    for (const option of list) {
+        for (const [field, text] of [
+            ['label', option.label],
+            ['value', option.value],
+            ['description', option.description],
+        ]) {
+            // A function is checked when the message is sent.
+            if (text === undefined || isDynamic(text))
+                continue;
+            if (text.trim() === '' || text.length > Limits.SelectOptionText) {
+                fail(`The ${field} of an option of ${what} is ${text.length} characters long: Discord accepts between 1 and ${Limits.SelectOptionText}.`);
+            }
+        }
+        if (values.has(option.value))
+            fail(`${what} has the value ${JSON.stringify(option.value)} twice.`);
+        values.add(option.value);
+    }
+    return list;
+}

package/dist/components/render.d.ts

@@ -0,0 +1,12 @@
+import { type RawComponent } from '../discord/types/component.js';
+import type { Translator } from '../messages/messages.js';
+export interface RenderedComponents {
+    raw: RawComponent[];
+    /** Whether the message needs the IS_COMPONENTS_V2 flag. */
+    v2: boolean;
+}
+/**
+ * The components of a message, as Discord takes them.
+ * @see https://docs.discord.com/developers/components/reference#component-object
+ */
+export declare function renderComponents(components: readonly unknown[], t?: Translator): RenderedComponents;

package/dist/components/render.js

@@ -0,0 +1,58 @@
+// Turns the `components` of a message into what Discord receives: rows made
+// by themselves, the whole checked against the limits of a message, and
+// whether the message is built with components only (Components V2).
+import { Limits } from '../discord/api.js';
+import { ComponentType, } from '../discord/types/component.js';
+import { renderedOf, resolve } from './instance.js';
+import { missingTranslator } from '../messages/translate.js';
+import { autoRows } from './layout.js';
+/** Every component of a tree, the nested ones included. */
+function count(components) {
+    let total = 0;
+    for (const component of components) {
+        total += 1;
+        if ('components' in component && Array.isArray(component.components)) {
+            total += count(component.components);
+        }
+        if ('accessory' in component)
+            total += 1;
+    }
+    return total;
+}
+/** The characters of every text of a tree. */
+function textLength(components) {
+    let total = 0;
+    for (const component of components) {
+        if (component.type === ComponentType.TextDisplay) {
+            total += component.content.length;
+        }
+        else if ('components' in component &&
+            Array.isArray(component.components)) {
+            total += textLength(component.components);
+        }
+    }
+    return total;
+}
+/**
+ * The components of a message, as Discord takes them.
+ * @see https://docs.discord.com/developers/components/reference#component-object
+ */
+export function renderComponents(components, t = missingTranslator(null)) {
+    if (!Array.isArray(components)) {
+        throw new TypeError(`The components of a message are a list, got ${typeof components}.`);
+    }
+    const pieces = components.map((component, index) => renderedOf(component, `Component ${index + 1} of the message`));
+    const rows = autoRows(pieces, 'a message');
+    const v2 = rows.some(one => one.kind !== 'row');
+    // The texts of a piece may be computed now, for who will read the message.
+    const raw = rows.map(one => resolve(one, t).raw);
+    const total = count(raw);
+    if (total > Limits.MessageComponents) {
+        throw new RangeError(`The message has ${total} components once its rows are made: Discord accepts ${Limits.MessageComponents} at most.`);
+    }
+    const characters = textLength(raw);
+    if (characters > Limits.TextDisplayTotal) {
+        throw new RangeError(`The texts of the components of the message add up to ${characters} characters: Discord accepts ${Limits.TextDisplayTotal} at most.`);
+    }
+    return { raw, v2 };
+}

package/dist/components/router.d.ts

@@ -0,0 +1,19 @@
+import { type RawInteraction } from '../discord/types/interaction.js';
+import { type Reporter } from '../interactions/dispatch.js';
+import type { Context } from '../structures/context.js';
+import type { LoadedComponent } from './declaration.js';
+/** A component, with the file and the export it comes from (to report its errors). */
+export interface ComponentEntry {
+    file: string;
+    export: string;
+    component: LoadedComponent;
+}
+export type ComponentRouterOptions = Reporter;
+export declare class ComponentRouter {
+    #private;
+    constructor(options: ComponentRouterOptions);
+    /** Replaces every component (after a load or a reload). */
+    set(entries: Iterable<ComponentEntry>): void;
+    /** Handles an Interaction Create event, if it is a component or a form. */
+    dispatch(ctx: Context, raw: RawInteraction): void;
+}