chapterjs 0.1.2 → 0.1.4

package/dist/core/bot.js

@@ -0,0 +1,174 @@
+// Assembles the core into a running bot: REST, cache, structures and the
+// gateway, with events applied to the cache before anyone hears of them.
+// Only the CLI creates one; user code never does.
+import { Cache } from '../cache/cache.js';
+import { Gateway, shardIdFor, } from '../gateway/gateway.js';
+import { applyDispatch } from '../gateway/state.js';
+import { RestClient } from '../rest/rest.js';
+import { createContext } from '../structures/entities.js';
+import { GatewayOpcode } from '../discord/codes.js';
+import { GatewayIntent } from '../discord/intents.js';
+import { VoiceManager } from '../voice/connection.js';
+/** The server a gateway event belongs to, when it belongs to one. */
+function guildIdOf(event, data) {
+    if (typeof data !== 'object' || data === null)
+        return undefined;
+    const fields = data;
+    // The events about a server itself carry its id as `id`.
+    const id = event === 'GUILD_CREATE' ||
+        event === 'GUILD_UPDATE' ||
+        event === 'GUILD_DELETE'
+        ? fields.id
+        : fields.guild_id;
+    return typeof id === 'string' ? id : undefined;
+}
+/**
+ * Whether an event that belongs to no server happened in a private
+ * conversation: it has a channel. What is about the bot itself (its user,
+ * its session) has none, and is always needed.
+ */
+function isPrivate(data) {
+    const fields = data;
+    return typeof fields.channel_id === 'string' || 'recipients' in fields;
+}
+export function createBot(options) {
+    const rest = new RestClient({
+        token: options.token,
+        version: options.version,
+        ...options.rest,
+    });
+    const ctx = createContext({ rest, cache: new Cache(options.cache) });
+    /** Servers announced by Ready whose data has not come yet, per shard. */
+    const pending = new Map();
+    let guildsReady = null;
+    let guildsTimer = null;
+    // Until every shard is ready, a shard whose servers all came is not the
+    // whole bot: the others have not said which servers they have.
+    let shardsReady = false;
+    const checkGuilds = () => {
+        if (!guildsReady || !shardsReady)
+            return;
+        for (const ids of pending.values())
+            if (ids.size > 0)
+                return;
+        finishGuilds();
+    };
+    const finishGuilds = () => {
+        if (guildsTimer)
+            clearTimeout(guildsTimer);
+        guildsTimer = null;
+        const done = guildsReady;
+        guildsReady = null;
+        if (done) {
+            done();
+            options.onEvent?.({ type: 'guildsReady' });
+        }
+    };
+    const gateway = new Gateway({
+        rest,
+        token: options.token,
+        intents: options.intents,
+        presence: options.presence,
+        shards: options.shards,
+        identifyGate: options.identifyGate,
+        ...options.gateway,
+        onEvent: options.onEvent,
+        onDispatch(event, data, shardId) {
+            let joined = false;
+            let awaited = false;
+            const filter = options.guildFilter;
+            if (event === 'READY') {
+                const ready = data;
+                if (filter) {
+                    // The cache and the wait for servers only know the allowed ones.
+                    data = {
+                        ...ready,
+                        guilds: ready.guilds.filter(guild => filter(guild.id)),
+                    };
+                }
+                pending.set(shardId, new Set(data.guilds.map(guild => guild.id)));
+            }
+            else {
+                const guildId = guildIdOf(event, data);
+                if (guildId === undefined) {
+                    if (options.privateEvents === false && isPrivate(data))
+                        return;
+                }
+                else if (filter && !filter(guildId)) {
+                    return;
+                }
+            }
+            if (event === 'GUILD_CREATE' || event === 'GUILD_DELETE') {
+                const { id } = data;
+                awaited = pending.get(shardId)?.delete(id) ?? false;
+                joined =
+                    event === 'GUILD_CREATE' && !awaited && !ctx.cache.guilds.has(id);
+            }
+            let before;
+            try {
+                before = options.beforeDispatch?.(event, data);
+            }
+            catch (error) {
+                options.onEvent?.({ type: 'stateError', event, error });
+            }
+            try {
+                applyDispatch(ctx, event, data, {
+                    shardId,
+                    shardCount: gateway.shardCount,
+                });
+            }
+            catch (error) {
+                options.onEvent?.({ type: 'stateError', event, error });
+            }
+            // The bot's own voice: where it is, and the server to send audio to.
+            if (event === 'VOICE_STATE_UPDATE') {
+                const state = data;
+                if (state.user_id === ctx.self?.userId)
+                    voice.onVoiceState(state);
+            }
+            else if (event === 'VOICE_SERVER_UPDATE') {
+                voice.onVoiceServer(data);
+            }
+            options.onDispatch?.(event, data, { shardId, joined, before });
+            if (awaited)
+                checkGuilds();
+        },
+    });
+    // Joining, moving and leaving voice go through the shard of the server.
+    const voice = new VoiceManager(ctx, {
+        updateVoiceState: data => gateway.send(shardIdFor(data.guild_id, gateway.shardCount), GatewayOpcode.VoiceStateUpdate, data),
+        hasVoiceStates: () => (options.intents & GatewayIntent.GuildVoiceStates) !== 0,
+    }, {
+        warn: message => options.onEvent?.({ type: 'voiceWarning', message }),
+        ...(options.voice?.secure === undefined
+            ? {}
+            : { secure: options.voice.secure }),
+    });
+    ctx.voice = voice;
+    return {
+        ctx,
+        gateway,
+        async connect() {
+            const allGuilds = new Promise(resolve => (guildsReady = resolve));
+            try {
+                await gateway.connect();
+            }
+            catch (error) {
+                guildsReady = null;
+                throw error;
+            }
+            shardsReady = true;
+            guildsTimer = setTimeout(finishGuilds, options.guildsTimeout ?? 15_000);
+            checkGuilds();
+            await allGuilds;
+        },
+        async close() {
+            if (guildsTimer)
+                clearTimeout(guildsTimer);
+            guildsTimer = null;
+            voice.closeAll();
+            await gateway.close();
+        },
+        setPresence: presence => gateway.setPresence(presence),
+    };
+}

package/dist/core/memory.d.ts

@@ -0,0 +1,66 @@
+import type { Cache, CacheLimits } from '../cache/cache.js';
+/** How much memory the process uses, and how much it can use, in bytes. */
+export interface MemoryReading {
+    used: number;
+    limit: number;
+}
+/** What Node says of its own memory. */
+export declare const readMemory: () => MemoryReading;
+/** What the bot remembers after its limits changed. */
+export interface MemoryLimits {
+    /** Members remembered per server, at most. */
+    members: number;
+    /** Users remembered, at most. */
+    users: number;
+}
+/**
+ * Sets what the bot remembers when memory is not a concern, for the files
+ * of the project as they are now. What exists follows at once.
+ */
+export declare function configure(cache: Cache, limits: Partial<CacheLimits>): void;
+/**
+ * Makes the bot remember half as much: half as many members per server,
+ * half as many users. The ones seen the longest ago leave. Servers,
+ * channels and roles stay: they are what keeps everything else true.
+ * Returns `null` when nothing is left to give up.
+ */
+export declare function tighten(cache: Cache): (MemoryLimits & {
+    forgotten: number;
+}) | null;
+/**
+ * Lets the bot remember more again, after memory was short: twice as many
+ * members per server, up to what was configured, and users as configured.
+ * Returns `null` when it already remembers all it may.
+ */
+export declare function relax(cache: Cache): MemoryLimits | null;
+export interface MemoryWatchOptions {
+    /** The cache of the running bot, if there is one right now. */
+    cache: () => Cache | undefined;
+    /** The bot remembers less, to free memory. */
+    onTightened: (now: MemoryLimits & {
+        forgotten: number;
+    }, reading: MemoryReading) => void;
+    /** Memory is fine again and the bot remembers all it may again. */
+    onRestored: (now: MemoryLimits) => void;
+    /**
+     * Memory is nearly full and nothing is left to give up. `freed` is what
+     * remembering less gave back, in bytes: little means the memory is not
+     * used by what the bot remembers.
+     */
+    onFull: (reading: MemoryReading, freed: number) => void;
+    /** How full memory must be to remember less, from 0 to 1. */
+    high?: number;
+    /** How empty memory must be to remember more again, from 0 to 1. */
+    low?: number;
+    /** How often memory is looked at, in milliseconds. */
+    every?: number;
+    read?: () => MemoryReading;
+}
+/**
+ * Looks at the memory of the process from time to time. `check()` looks
+ * right now; `stop()` ends it.
+ */
+export declare function watchMemory(options: MemoryWatchOptions): {
+    check(): void;
+    stop(): void;
+};

package/dist/core/memory.js

@@ -0,0 +1,115 @@
+// Keeps the memory of the bot under control by itself. What the cache keeps
+// is bounded per server, but not in total: a bot in many servers can still
+// fill the memory of its process. Before that happens, the bot remembers
+// less: it lowers its own limits, and raises them back when memory is fine
+// again. It only asks for something when it has nothing left to give up.
+import { getHeapStatistics } from 'node:v8';
+import { storesOf } from '../structures/guild.js';
+/** What Node says of its own memory. */
+export const readMemory = () => ({
+    used: process.memoryUsage().heapUsed,
+    limit: getHeapStatistics().heap_size_limit,
+});
+/** Applies limits to what exists, and to what will. Returns what left. */
+function apply(cache, limits) {
+    cache.setLimits(limits);
+    let forgotten = cache.users.resize(limits.users);
+    for (const guild of cache.guilds.values()) {
+        forgotten += storesOf(guild).members.resize(limits.members);
+    }
+    return forgotten;
+}
+/**
+ * Sets what the bot remembers when memory is not a concern, for the files
+ * of the project as they are now. What exists follows at once.
+ */
+export function configure(cache, limits) {
+    cache.configure(limits);
+    apply(cache, { members: cache.limits.members, users: cache.limits.users });
+}
+/**
+ * Makes the bot remember half as much: half as many members per server,
+ * half as many users. The ones seen the longest ago leave. Servers,
+ * channels and roles stay: they are what keeps everything else true.
+ * Returns `null` when nothing is left to give up.
+ */
+export function tighten(cache) {
+    const { members, users } = cache.limits;
+    // Users have no limit of their own: half of the ones known today.
+    const limits = {
+        members: Math.floor(members / 2),
+        users: Math.floor(Math.min(users, cache.users.size) / 2),
+    };
+    if (limits.members === members && limits.users === users)
+        return null;
+    return { ...limits, forgotten: apply(cache, limits) };
+}
+/**
+ * Lets the bot remember more again, after memory was short: twice as many
+ * members per server, up to what was configured, and users as configured.
+ * Returns `null` when it already remembers all it may.
+ */
+export function relax(cache) {
+    const { members, users } = cache.limits;
+    const limits = {
+        members: Math.min(cache.configured.members, Math.max(1, members * 2)),
+        users: cache.configured.users,
+    };
+    if (limits.members === members && limits.users === users)
+        return null;
+    apply(cache, limits);
+    return limits;
+}
+/**
+ * Looks at the memory of the process from time to time. `check()` looks
+ * right now; `stop()` ends it.
+ */
+export function watchMemory(options) {
+    const { high = 0.8, low = 0.5, every = 30_000, read = readMemory } = options;
+    let highs = 0;
+    let lows = 0;
+    let said = false;
+    /** What was used when the bot started to remember less. */
+    let before;
+    const check = () => {
+        const reading = read();
+        const cache = options.cache();
+        if (reading.used >= reading.limit * high) {
+            lows = 0;
+            // Node frees memory by itself when it gets full: only a level that
+            // stays high means something has to go.
+            if (++highs < 2)
+                return;
+            const now = cache ? tighten(cache) : null;
+            if (now) {
+                before ??= reading.used;
+                options.onTightened(now, reading);
+            }
+            else if (!said) {
+                // Said once, until memory is no longer full.
+                said = true;
+                options.onFull(reading, before === undefined ? 0 : Math.max(0, before - reading.used));
+            }
+            return;
+        }
+        highs = 0;
+        said = false;
+        before = undefined;
+        // Between the two levels nothing moves: limits don't go up and down.
+        if (reading.used >= reading.limit * low) {
+            lows = 0;
+            return;
+        }
+        if (++lows < 2 || !cache)
+            return;
+        const now = relax(cache);
+        // Said when everything is back, not at every step up.
+        if (now && now.members === cache.configured.members) {
+            options.onRestored(now);
+        }
+    };
+    const timer = setInterval(check, every);
+    // Never what keeps the process alive.
+    timer.unref();
+    return { check, stop: () => clearInterval(timer) };
+}

package/dist/discord/api.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The API and gateway version the framework speaks.
+ * @see https://docs.discord.com/developers/reference#api-versioning
+ */
+export declare const API_VERSION = 10;
+/** @see https://docs.discord.com/developers/reference#api-reference */
+export declare const API_BASE_URL = "https://discord.com/api";
+/** @see https://docs.discord.com/developers/reference#image-formatting */
+export declare const CDN_BASE_URL = "https://cdn.discordapp.com";
+/**
+ * Sticker GIFs are not served by the CDN base URL.
+ * @see https://docs.discord.com/developers/reference#image-formatting
+ */
+export declare const MEDIA_BASE_URL = "https://media.discordapp.net";
+/**
+ * Milliseconds since the first second of 2015: where snowflake time starts.
+ * @see https://docs.discord.com/developers/reference#snowflakes
+ */
+export declare const DISCORD_EPOCH = 1420070400000n;
+/**
+ * How many requests per second a bot can make in total.
+ * @see https://docs.discord.com/developers/topics/rate-limits#global-rate-limit
+ */
+export declare const GLOBAL_REQUESTS_PER_SECOND = 50;
+/**
+ * The longest reason an audit log entry accepts, in characters.
+ * @see https://docs.discord.com/developers/resources/audit-log#audit-log-entry-object
+ */
+export declare const AUDIT_LOG_REASON_MAX_LENGTH = 512;
+/**
+ * The value of the `User-Agent` header Discord requires.
+ * @see https://docs.discord.com/developers/reference#user-agent
+ */
+export declare function userAgent(version: string): string;
+/**
+ * Limits Discord enforces on what a bot sends: checked before sending, so
+ * the developer gets a clear message instead of an "Invalid Form Body".
+ */
+export declare const Limits: {
+    /** @see https://docs.discord.com/developers/resources/message#create-message */
+    readonly MessageContent: 2000;
+    readonly MessageEmbeds: 10;
+    readonly MessageStickers: 3;
+    /** @see https://docs.discord.com/developers/reference#uploading-files */
+    readonly MessageAttachments: 10;
+    /** @see https://docs.discord.com/developers/resources/message#embed-object-embed-limits */
+    readonly EmbedTitle: 256;
+    readonly EmbedDescription: 4096;
+    readonly EmbedFields: 25;
+    readonly EmbedFieldName: 256;
+    readonly EmbedFieldValue: 1024;
+    readonly EmbedFooterText: 2048;
+    readonly EmbedAuthorName: 256;
+    /** The characters of every embed of a message, added up. */
+    readonly EmbedTotal: 6000;
+    /** @see https://docs.discord.com/developers/resources/message#bulk-delete-messages */
+    readonly BulkDeleteMin: 2;
+    readonly BulkDeleteMax: 100;
+    /** Bulk delete refuses messages older than two weeks, in milliseconds. */
+    readonly BulkDeleteMaxAge: number;
+    /** @see https://docs.discord.com/developers/resources/guild#list-guild-members */
+    readonly ListGuildMembers: 1000;
+    /** @see https://docs.discord.com/developers/resources/message#get-channel-messages */
+    readonly GetChannelMessages: 100;
+    /** @see https://docs.discord.com/developers/resources/guild#bulk-guild-ban */
+    readonly BulkBanUsers: 200;
+    /** Seconds of messages a ban can delete: 7 days. */
+    readonly BanDeleteMessageSeconds: 604800;
+    /** @see https://docs.discord.com/developers/resources/user#usernames-and-nicknames */
+    readonly Nickname: 32;
+    /** A timeout can't end more than 28 days from now, in milliseconds. */
+    readonly TimeoutMaxDuration: number;
+    /** @see https://docs.discord.com/developers/components/reference#anatomy-of-a-component-custom-id */
+    readonly CustomId: 100;
+    /** @see https://docs.discord.com/developers/components/reference#component-object */
+    readonly MessageComponents: 40;
+    /** @see https://docs.discord.com/developers/components/reference#action-row */
+    readonly ActionRowButtons: 5;
+    /** @see https://docs.discord.com/developers/components/reference#button-button-structure */
+    readonly ButtonLabel: 80;
+    readonly ButtonUrl: 512;
+    /** @see https://docs.discord.com/developers/components/reference#string-select-string-select-structure */
+    readonly SelectOptions: 25;
+    readonly SelectPlaceholder: 150;
+    /** The label, the value and the description of one option of a menu. */
+    readonly SelectOptionText: 100;
+    readonly SelectValues: 25;
+    /** The characters of every text of a message built with components. */
+    readonly TextDisplayTotal: 4000;
+    /** @see https://docs.discord.com/developers/components/reference#section-section-structure */
+    readonly SectionTexts: 3;
+    /** @see https://docs.discord.com/developers/components/reference#media-gallery-media-gallery-structure */
+    readonly MediaGalleryItems: 10;
+    readonly MediaDescription: 1024;
+    /** @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-modal */
+    readonly ModalTitle: 45;
+    readonly ModalFields: 5;
+    /** @see https://docs.discord.com/developers/components/reference#label-label-structure */
+    readonly LabelText: 45;
+    readonly LabelDescription: 100;
+    /** @see https://docs.discord.com/developers/components/reference#text-input-text-input-structure */
+    readonly TextInputLength: 4000;
+    readonly TextInputPlaceholder: 100;
+    /** @see https://docs.discord.com/developers/components/reference#file-upload-file-upload-structure */
+    readonly FileUploadMax: 10;
+    readonly FileUploadTypes: 10;
+    /** @see https://docs.discord.com/developers/components/reference#radio-group-structure */
+    readonly RadioOptionsMin: 2;
+    readonly RadioOptions: 10;
+    /** @see https://docs.discord.com/developers/components/reference#checkbox-group-structure */
+    readonly CheckboxOptions: 10;
+};

package/dist/discord/api.js

@@ -0,0 +1,115 @@
+// Constants of the Discord API that never depend on a bot.
+/**
+ * The API and gateway version the framework speaks.
+ * @see https://docs.discord.com/developers/reference#api-versioning
+ */
+export const API_VERSION = 10;
+/** @see https://docs.discord.com/developers/reference#api-reference */
+export const API_BASE_URL = 'https://discord.com/api';
+/** @see https://docs.discord.com/developers/reference#image-formatting */
+export const CDN_BASE_URL = 'https://cdn.discordapp.com';
+/**
+ * Sticker GIFs are not served by the CDN base URL.
+ * @see https://docs.discord.com/developers/reference#image-formatting
+ */
+export const MEDIA_BASE_URL = 'https://media.discordapp.net';
+/**
+ * Milliseconds since the first second of 2015: where snowflake time starts.
+ * @see https://docs.discord.com/developers/reference#snowflakes
+ */
+export const DISCORD_EPOCH = 1420070400000n;
+/**
+ * How many requests per second a bot can make in total.
+ * @see https://docs.discord.com/developers/topics/rate-limits#global-rate-limit
+ */
+export const GLOBAL_REQUESTS_PER_SECOND = 50;
+/**
+ * The longest reason an audit log entry accepts, in characters.
+ * @see https://docs.discord.com/developers/resources/audit-log#audit-log-entry-object
+ */
+export const AUDIT_LOG_REASON_MAX_LENGTH = 512;
+/**
+ * The value of the `User-Agent` header Discord requires.
+ * @see https://docs.discord.com/developers/reference#user-agent
+ */
+export function userAgent(version) {
+    return `DiscordBot (https://github.com/chapterjs/chapterjs, ${version})`;
+}
+/**
+ * Limits Discord enforces on what a bot sends: checked before sending, so
+ * the developer gets a clear message instead of an "Invalid Form Body".
+ */
+export const Limits = {
+    /** @see https://docs.discord.com/developers/resources/message#create-message */
+    MessageContent: 2000,
+    MessageEmbeds: 10,
+    MessageStickers: 3,
+    /** @see https://docs.discord.com/developers/reference#uploading-files */
+    MessageAttachments: 10,
+    /** @see https://docs.discord.com/developers/resources/message#embed-object-embed-limits */
+    EmbedTitle: 256,
+    EmbedDescription: 4096,
+    EmbedFields: 25,
+    EmbedFieldName: 256,
+    EmbedFieldValue: 1024,
+    EmbedFooterText: 2048,
+    EmbedAuthorName: 256,
+    /** The characters of every embed of a message, added up. */
+    EmbedTotal: 6000,
+    /** @see https://docs.discord.com/developers/resources/message#bulk-delete-messages */
+    BulkDeleteMin: 2,
+    BulkDeleteMax: 100,
+    /** Bulk delete refuses messages older than two weeks, in milliseconds. */
+    BulkDeleteMaxAge: 14 * 24 * 60 * 60 * 1000,
+    /** @see https://docs.discord.com/developers/resources/guild#list-guild-members */
+    ListGuildMembers: 1000,
+    /** @see https://docs.discord.com/developers/resources/message#get-channel-messages */
+    GetChannelMessages: 100,
+    /** @see https://docs.discord.com/developers/resources/guild#bulk-guild-ban */
+    BulkBanUsers: 200,
+    /** Seconds of messages a ban can delete: 7 days. */
+    BanDeleteMessageSeconds: 604_800,
+    /** @see https://docs.discord.com/developers/resources/user#usernames-and-nicknames */
+    Nickname: 32,
+    /** A timeout can't end more than 28 days from now, in milliseconds. */
+    TimeoutMaxDuration: 28 * 24 * 60 * 60 * 1000,
+    /** @see https://docs.discord.com/developers/components/reference#anatomy-of-a-component-custom-id */
+    CustomId: 100,
+    /** @see https://docs.discord.com/developers/components/reference#component-object */
+    MessageComponents: 40,
+    /** @see https://docs.discord.com/developers/components/reference#action-row */
+    ActionRowButtons: 5,
+    /** @see https://docs.discord.com/developers/components/reference#button-button-structure */
+    ButtonLabel: 80,
+    ButtonUrl: 512,
+    /** @see https://docs.discord.com/developers/components/reference#string-select-string-select-structure */
+    SelectOptions: 25,
+    SelectPlaceholder: 150,
+    /** The label, the value and the description of one option of a menu. */
+    SelectOptionText: 100,
+    SelectValues: 25,
+    /** The characters of every text of a message built with components. */
+    TextDisplayTotal: 4000,
+    /** @see https://docs.discord.com/developers/components/reference#section-section-structure */
+    SectionTexts: 3,
+    /** @see https://docs.discord.com/developers/components/reference#media-gallery-media-gallery-structure */
+    MediaGalleryItems: 10,
+    MediaDescription: 1024,
+    /** @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-response-object-modal */
+    ModalTitle: 45,
+    ModalFields: 5,
+    /** @see https://docs.discord.com/developers/components/reference#label-label-structure */
+    LabelText: 45,
+    LabelDescription: 100,
+    /** @see https://docs.discord.com/developers/components/reference#text-input-text-input-structure */
+    TextInputLength: 4000,
+    TextInputPlaceholder: 100,
+    /** @see https://docs.discord.com/developers/components/reference#file-upload-file-upload-structure */
+    FileUploadMax: 10,
+    FileUploadTypes: 10,
+    /** @see https://docs.discord.com/developers/components/reference#radio-group-structure */
+    RadioOptionsMin: 2,
+    RadioOptions: 10,
+    /** @see https://docs.discord.com/developers/components/reference#checkbox-group-structure */
+    CheckboxOptions: 10,
+};

package/dist/discord/cdn.d.ts

@@ -0,0 +1,67 @@
+import type { Snowflake } from './types/common.js';
+import { StickerFormatType } from './types/sticker.js';
+/** @see https://docs.discord.com/developers/reference#image-formatting-image-formats */
+export type ImageFormat = 'png' | 'jpg' | 'jpeg' | 'webp' | 'gif';
+/** Image size can be any power of two between 16 and 4096. */
+export type ImageSize = 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
+export interface ImageOptions {
+    /**
+     * The file format. By default: WebP, which Discord recommends since it
+     * works for still and animated images, whatever was uploaded.
+     */
+    format?: ImageFormat;
+    /** The size in pixels: a power of two between 16 and 4096. */
+    size?: ImageSize;
+    /**
+     * `false` to get the first frame of an animated image. By default an
+     * animated image stays animated.
+     */
+    animated?: boolean;
+}
+/** @see https://docs.discord.com/developers/reference#image-formatting-cdn-endpoints */
+export declare const cdn: {
+    /** Custom Emoji */
+    readonly emoji: (emojiId: Snowflake, animated: boolean, options?: ImageOptions) => string;
+    /** Guild Icon */
+    readonly guildIcon: (guildId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Splash */
+    readonly guildSplash: (guildId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Discovery Splash */
+    readonly guildDiscoverySplash: (guildId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Banner */
+    readonly guildBanner: (guildId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** User Banner */
+    readonly userBanner: (userId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /**
+     * Default User Avatar: always a PNG of a fixed size. The index is
+     * `(user_id >> 22) % 6` for users on the new username system and
+     * `discriminator % 5` for the others.
+     */
+    readonly defaultUserAvatar: (userId: Snowflake, discriminator: string) => string;
+    /** User Avatar */
+    readonly userAvatar: (userId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Member Avatar */
+    readonly memberAvatar: (guildId: Snowflake, userId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Member Banner */
+    readonly memberBanner: (guildId: Snowflake, userId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Avatar Decoration: always a PNG. */
+    readonly avatarDecoration: (asset: string) => string;
+    /** Application Icon */
+    readonly applicationIcon: (applicationId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Application Cover */
+    readonly applicationCover: (applicationId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Team Icon */
+    readonly teamIcon: (teamId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /**
+     * Sticker: a PNG if its format is PNG or APNG, a Lottie file (`.json`) if
+     * it is LOTTIE, and a GIF served by another host if it is GIF. The size
+     * is fixed.
+     */
+    readonly sticker: (stickerId: Snowflake, format: StickerFormatType) => string;
+    /** Role Icon */
+    readonly roleIcon: (roleId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Scheduled Event Cover */
+    readonly scheduledEventCover: (eventId: Snowflake, hash: string, options?: ImageOptions) => string;
+    /** Guild Tag Badge */
+    readonly guildTagBadge: (guildId: Snowflake, hash: string, options?: ImageOptions) => string;
+};