chapterjs 0.1.2 → 0.2.0

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 your languages. They have: ${[...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: 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: declare one with language({ locale: 'en-US', texts: { ... } }) 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, 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/declaration.d.ts

@@ -0,0 +1,19 @@
+import type { Declaration } from '../loader/loader.js';
+import { type RawGatewayPresenceUpdate } from '../discord/types/gateway-events.js';
+/** The presence, 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 shows: online, doing nothing. Sent when
+ * the declaration is removed while the bot runs.
+ */
+export declare const DEFAULT_PRESENCE: RawGatewayPresenceUpdate;
+/**
+ * The presence of the bot, declared once anywhere in `src/` with
+ * `presence()` and exported.
+ */
+export declare const presenceDeclaration: Declaration<LoadedPresence>;

package/dist/presence/declaration.js

@@ -0,0 +1,118 @@
+// What a file declares with `presence()`: what the bot shows under its
+// name. It 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 { isPresenceDeclaration } 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 shows: online, doing nothing. Sent when
+ * the declaration 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,
+    };
+}
+/**
+ * The presence of the bot, declared once anywhere in `src/` with
+ * `presence()` and exported.
+ */
+export const presenceDeclaration = {
+    one: 'presence',
+    many: 'presences',
+    is: isPresenceDeclaration,
+    list: false,
+    read(value) {
+        const config = value.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 a file 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: a declaration the framework finds in the exports of a file. */
+export interface PresenceDeclaration {
+    /** 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 from any file of `src/`, once; 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): PresenceDeclaration;
+/** Whether a value was made by `presence()`. */
+export declare function isPresenceDeclaration(value: unknown): value is PresenceDeclaration;

package/dist/presence/presence.js

@@ -0,0 +1,27 @@
+// `presence()`, as user files import 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 from any file of `src/`, once; 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 isPresenceDeclaration(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();
+}

package/dist/rest/errors.js

@@ -0,0 +1,92 @@
+import { JSON_ERROR_CODES } from '../discord/codes.js';
+/**
+ * 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 function flattenFieldErrors(errors, path = '') {
+    if (typeof errors !== 'object' || errors === null)
+        return [];
+    const found = [];
+    for (const [key, value] of Object.entries(errors)) {
+        if (key === '_errors') {
+            if (!Array.isArray(value))
+                continue;
+            for (const error of value) {
+                found.push({
+                    path,
+                    code: String(error?.code ?? ''),
+                    message: String(error?.message ?? ''),
+                });
+            }
+            continue;
+        }
+        const child = /^\d+$/.test(key)
+            ? `${path}[${key}]`
+            : path === ''
+                ? key
+                : `${path}.${key}`;
+        found.push(...flattenFieldErrors(value, child));
+    }
+    return found;
+}
+/** Discord answered a request with an error. */
+export class DiscordApiError extends Error {
+    name = 'DiscordApiError';
+    /** The HTTP status of the response (403, 404...). */
+    status;
+    /**
+     * 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
+     */
+    code;
+    /** The fields of the request Discord refused, when it says which. */
+    fieldErrors;
+    /** The HTTP method of the request that failed. */
+    method;
+    /** The path of the endpoint as written in the documentation. */
+    route;
+    constructor(input) {
+        const body = typeof input.body === 'object' && input.body !== null
+            ? input.body
+            : {};
+        const code = typeof body.code === 'number' ? body.code : 0;
+        const fieldErrors = flattenFieldErrors(body.errors);
+        const reason = typeof body.message === 'string' && body.message !== ''
+            ? body.message
+            : ((typeof body.code === 'number'
+                ? JSON_ERROR_CODES[code]
+                : undefined) ?? `HTTP ${input.status}`);
+        const details = fieldErrors
+            .map(error => `\n  ${error.path || 'request'}: ${error.message}`)
+            .join('');
+        super(`Discord refused ${input.method} ${input.route}: ${reason} (${code || input.status})${details}`);
+        this.status = input.status;
+        this.code = code;
+        this.fieldErrors = fieldErrors;
+        this.method = input.method;
+        this.route = input.route;
+    }
+}
+/** A request could not reach Discord, or Discord kept failing. */
+export class DiscordUnavailableError extends Error {
+    name = 'DiscordUnavailableError';
+    /** The HTTP method of the request that failed. */
+    method;
+    /** The path of the endpoint as written in the documentation. */
+    route;
+    constructor(method, route, cause) {
+        super(`Discord could not be reached for ${method} ${route}. Check your internet connection and https://discordstatus.com, then try again.`, { cause });
+        this.method = method;
+        this.route = route;
+    }
+}
+/** The bot token was refused: no request can succeed until it is fixed. */
+export class InvalidTokenError extends Error {
+    name = 'InvalidTokenError';
+    constructor() {
+        super('Discord refused the bot token. Copy it again from the Developer Portal (your application → Bot → Reset Token) into BOT_TOKEN in your .env file.');
+    }
+}

package/dist/rest/rate-limiter.d.ts

@@ -0,0 +1,46 @@
+/** What the headers of a response say about the rate limit of its route. */
+export interface RateLimitHeaders {
+    /** `X-RateLimit-Bucket`: routes sharing a limit share this value. */
+    bucket: string | null;
+    /** `X-RateLimit-Remaining` */
+    remaining: number | null;
+    /** `X-RateLimit-Reset-After`, in seconds. */
+    resetAfter: number | null;
+}
+/** A 429 response. */
+export interface RateLimitHit {
+    /** `Retry-After` / `retry_after`, in seconds. */
+    retryAfter: number;
+    /** `X-RateLimit-Scope`: `user`, `global` or `shared`. */
+    scope: string | null;
+    /** `X-RateLimit-Global` */
+    global: boolean;
+}
+export declare function readRateLimitHeaders(headers: Headers): RateLimitHeaders;
+export interface RateLimiterOptions {
+    /** Requests per second for the whole bot. Default: 50. */
+    globalLimit?: number;
+    /** Called every time a request has to wait. */
+    onWait?: (info: {
+        route: string;
+        ms: number;
+        global: boolean;
+    }) => void;
+}
+export declare class RateLimiter {
+    #private;
+    constructor(options?: RateLimiterOptions);
+    /**
+     * Runs `send` when the limits allow it. Requests of the same bucket run
+     * one after the other; different buckets run in parallel. `send` reports
+     * what the response said through `update` and returns its result, or a
+     * `RateLimitHit` to be run again after the delay Discord asked for.
+     */
+    run<T>(input: {
+        route: string;
+        major: string;
+        /** Interaction endpoints are not bound to the global rate limit. */
+        countsForGlobal: boolean;
+    }, send: (update: (headers: RateLimitHeaders) => void) => Promise<T | RateLimitHit>): Promise<T>;
+}
+export declare function rateLimitHit(hit: RateLimitHit): RateLimitHit;