@squord/sdk 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2340 @@
+import { B as ButtonStyle, A as APIButton, a as APISelectOption, b as APISelectMenu, c as APIComponentRow, d as APIEmbedInput, e as APIEmbed, f as AllowedMentions, S as Snowflake, g as APIMessageCreateBody, h as APICommand, i as APICommandInput, j as APIBot, k as APICurrentUser, l as APIChannel, m as APIChannelTreeNode, n as APIThreadCreateBody, o as APIThread, p as APIForumPostCreateBody, q as APIThreadListParams, r as APIThreadPage, s as APIInteractionCallbackBody, t as APIInteractionReplyData, u as APIGuild, v as APIMember, C as CursorPaginationParams, w as APIMemberPage, x as APIMemberEditBody, I as ISODate, y as APIRole, z as APIMemberBanBody, D as APIMemberBan, E as APIMessage, F as APIMessageListParams, G as APIMessagePage, H as APIReaction, J as APIUploadCreateBody, K as APIUploadReservation, L as APIUploadConfirmBody, M as APIUpload, N as APIUser, O as MessageType, T as ThreadAutoArchiveMinutes, P as ChannelType, Q as APIInteraction, R as APIInteractionCommandData, U as APIInteractionComponentData, V as CommandOptionType, W as PermissionBits, X as APIChannelOverwrite, Y as APICommandOptionInput, Z as Page, _ as APIErrorBody, $ as APIValidationIssue } from './api-DbHoBFJY.js';
+export { a0 as APIAttachment, a1 as APICommandOption, a2 as APICommandOptionChoice, a3 as APIForumTag, a4 as APIGuildRule, a5 as APIGuildSelf, a6 as APIMessageEditBody, a7 as APIMessageReplyTo, a8 as APIUploadTarget, a9 as AttachmentScanStatus, aa as Cursor, ab as GuildFlags, ac as InteractionCallbackType, ad as InteractionType, ae as MemberType, af as Nonce, ag as RoleManagedKind, ah as UploadStatus, ai as UserFlags, aj as channelMention, ak as roleMention, al as userMention } from './api-DbHoBFJY.js';
+import { Readable } from 'node:stream';
+
+/**
+ * Event emitter tipado, sem dependências externas.
+ *
+ * Suporta `on`, `once`, `off` e `emit`, com mapa de eventos estritamente
+ * tipado. Handlers síncronos e assíncronos são aceitos; erros de handlers
+ * assíncronos são capturados e entregues ao evento `error` da mesma instância
+ * (ou `uncaught`), sem derrubar o processo.
+ */
+type EventHandler<K> = [K] extends [unknown[]] ? (...args: K) => unknown : (payload: K) => unknown;
+/** Converte o tipo de payload em tupla de argumentos (sem distribuir unions). */
+type ArgsOf<K> = [K] extends [unknown[]] ? K : [K];
+interface EventMap {
+    [event: string]: unknown;
+}
+declare class TypedEmitter<Events extends EventMap> {
+    private handlers;
+    /** Registra um handler. Devolve uma função que o remove. */
+    on<E extends keyof Events>(event: E, handler: EventHandler<Events[E]>): () => void;
+    /** Registra um handler que é removido após a primeira chamada. */
+    once<E extends keyof Events>(event: E, handler: EventHandler<Events[E]>): () => void;
+    /** Remove um handler (ou todos do evento, se omitido). */
+    off<E extends keyof Events>(event: E, handler?: EventHandler<Events[E]>): void;
+    /** Remove todos os handlers de todos os eventos. */
+    removeAllListeners(): void;
+    /** Emite um evento. Erros síncronos de handlers propagam para `error`. */
+    emit<E extends keyof Events>(event: E, ...args: ArgsOf<Events[E]>): boolean;
+    /** Quantos handlers estão registrados para um evento. */
+    listenerCount<E extends keyof Events>(event: E): number;
+    /** Nomes de eventos com pelo menos um handler. */
+    eventNames(): Array<keyof Events>;
+    private handleAsyncError;
+}
+
+/**
+ * Builders de componentes: botões e menus de seleção.
+ *
+ * Regras do Squord: uma mensagem tem até 5 linhas; cada linha guarda até 5
+ * botões **ou** exatamente 1 menu (nunca os dois); `customId` é único na
+ * mensagem (até 100 caracteres); `link` tem `url` e não tem `customId`.
+ */
+
+declare const ComponentLimits: {
+    readonly RowsPerMessage: 5;
+    readonly ButtonsPerRow: 5;
+    readonly CustomId: 100;
+    readonly Label: 80;
+    readonly OptionsPerMenu: 25;
+};
+declare class ButtonBuilder {
+    private readonly style;
+    private labelValue;
+    private customIdValue;
+    private urlValue;
+    private disabledValue;
+    constructor(style: ButtonStyle, labelValue: string);
+    /** Identificador da ação; obrigatório (e único na mensagem) fora do estilo `link`. */
+    setCustomId(customId: string): this;
+    /** URL aberta ao clicar; obrigatória e exclusiva do estilo `link`. */
+    setURL(url: string): this;
+    setDisabled(disabled: boolean): this;
+    setLabel(label: string): this;
+    build(): APIButton;
+}
+declare class SelectMenuBuilder {
+    private readonly customId;
+    private placeholderValue;
+    private minValuesValue;
+    private maxValuesValue;
+    private disabledValue;
+    private optionsValue;
+    constructor(customId: string);
+    setPlaceholder(placeholder: string): this;
+    setMinValues(min: number): this;
+    setMaxValues(max: number): this;
+    setDisabled(disabled: boolean): this;
+    addOption(option: APISelectOption): this;
+    addOptions(...options: APISelectOption[]): this;
+    build(): APISelectMenu;
+}
+declare class ActionRowBuilder {
+    private components;
+    /** Adiciona um botão (até 5 por linha). */
+    addButton(button: ButtonBuilder | APIButton): this;
+    /** Define o menu da linha (exatamente 1, sozinho). */
+    setSelectMenu(menu: SelectMenuBuilder | APISelectMenu): this;
+    addComponents(...components: Array<ButtonBuilder | SelectMenuBuilder | APIButton | APISelectMenu>): this;
+    build(): APIComponentRow;
+}
+/** Atalhos para botões dos quatro estilos. */
+declare const Buttons: {
+    primary: (label: string) => ButtonBuilder;
+    secondary: (label: string) => ButtonBuilder;
+    danger: (label: string) => ButtonBuilder;
+    link: (label: string) => ButtonBuilder;
+};
+
+/**
+ * `EmbedBuilder`: cria embeds tipados com validação local dos limites reais
+ * da plataforma (antes de gastar uma chamada com um `422 VALIDATION_FAILED`).
+ *
+ * Limites do Squord: 10 embeds por mensagem, 25 campos por embed, título 256,
+ * descrição 4096, nome de campo 256, valor de campo 1024, rodapé 2048,
+ * autor 256 e 6000 caracteres somando o texto dos embeds da mensagem.
+ */
+
+declare const EmbedLimits: {
+    readonly EmbedsPerMessage: 10;
+    readonly FieldsPerEmbed: 25;
+    readonly Title: 256;
+    readonly Description: 4096;
+    readonly FieldName: 256;
+    readonly FieldValue: 1024;
+    readonly FooterText: 2048;
+    readonly AuthorName: 256;
+    readonly TotalTextPerMessage: 6000;
+};
+interface EmbedFieldInput {
+    name: string;
+    value: string;
+    inline?: boolean;
+}
+interface EmbedAuthorInput {
+    name: string;
+    url?: string | null;
+    iconUrl?: string | null;
+}
+interface EmbedFooterInput {
+    text: string;
+    iconUrl?: string | null;
+}
+/** Converte cores: `#rrggbb` → inteiro, inteiro → `#rrggbb`. */
+declare function normalizeEmbedColor(color: number | string): number;
+declare class EmbedBuilder {
+    private titleValue;
+    private descriptionValue;
+    private urlValue;
+    private colorValue;
+    private timestampValue;
+    private authorValue;
+    private footerValue;
+    private imageValue;
+    private thumbnailValue;
+    private fieldsValue;
+    /** Título do embed (até 256 caracteres). */
+    setTitle(title: string): this;
+    /** Descrição (até 4096 caracteres). */
+    setDescription(description: string): this;
+    /** URL do título (só `http://` ou `https://`). */
+    setURL(url: string): this;
+    /** Cor: inteiro de 0 a 16777215 ou `#rrggbb`. */
+    setColor(color: number | string): this;
+    /** Momento exibido no rodapé. Um `Date` ou string ISO 8601 com fuso. */
+    setTimestamp(timestamp?: Date | string): this;
+    /** Autor exibido no topo (nome até 256 caracteres). */
+    setAuthor(author: EmbedAuthorInput | null): this;
+    /** Rodapé (texto até 2048 caracteres). */
+    setFooter(footer: EmbedFooterInput | null): this;
+    /** Imagem principal (baixada e hospedada pelo Squord em segundo plano). */
+    setImage(url: string): this;
+    /** Miniatura. */
+    setThumbnail(url: string): this;
+    /** Adiciona um campo (nome até 256, valor até 1024). */
+    addField(name: string, value: string, inline?: boolean): this;
+    /** Adiciona vários campos. */
+    addFields(...fields: EmbedFieldInput[]): this;
+    /** Remove todos os campos. */
+    clearFields(): this;
+    /** Payload pronto para o campo `embeds` (só campos preenchidos). */
+    build(): APIEmbedInput;
+    /** Soma dos textos do embed (para conferir o limite de 6000 por mensagem). */
+    get textLength(): number;
+    /** Cria um builder a partir de um payload existente. */
+    static from(embed: APIEmbed | APIEmbedInput): EmbedBuilder;
+}
+
+/**
+ * Normalização de payloads de mensagem: aceita strings, objetos crus e
+ * builders, e devolve o corpo aceito pela API.
+ *
+ * Menções são seguras por padrão: quando `allowedMentions` não é informado,
+ * o SDK envia `{ users: true, roles: false, everyone: false }` — o padrão
+ * da plataforma — evitando menções acidentais em massa.
+ */
+
+/** Payload de envio/edição aceito pelos métodos `send`/`reply`/`edit`. */
+interface MessagePayload {
+    content?: string;
+    embeds?: Array<APIEmbedInput | EmbedBuilder>;
+    components?: Array<APIComponentRow | ActionRowBuilder>;
+    allowedMentions?: AllowedMentions;
+    replyToId?: Snowflake;
+    attachmentIds?: Snowflake[];
+    nonce?: string;
+    ephemeral?: boolean;
+}
+/** Uma mensagem pode ser passada como string (só `content`) ou como payload. */
+type MessagePayloadLike = string | MessagePayload;
+/** Converte builders e valores crus no formato da API. */
+declare function resolveMessagePayload(payload: MessagePayloadLike): APIMessageCreateBody & {
+    ephemeral?: boolean;
+};
+
+/**
+ * Logger estruturado com redação automática de segredos.
+ *
+ * Tokens de bot (`sqb_...`) e tokens de interação são substituídos por
+ * `[REDACTED]` antes de qualquer entrega. O logger nunca registra o conteúdo
+ * de mensagens por conta própria: os eventos são emitidos, mas o logger só
+ * fala de metadados operacionais.
+ */
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+interface Logger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    /** Cria um logger filho com campos fixos (ex.: `rest`, `gateway`). */
+    child(prefix: string): Logger;
+}
+/** Redação aplicada a todas as saídas do logger padrão. */
+declare function redact(input: string): string;
+interface ConsoleLoggerOptions {
+    /** Nível mínimo exibido. Padrão: `silent` (o SDK não imprime nada). */
+    level?: LogLevel;
+    /** Destino dos logs. Padrão: `console`. */
+    write?: (line: string) => void;
+}
+declare function createConsoleLogger(options?: ConsoleLoggerOptions): Logger;
+/** Logger que descarta tudo. Útil como padrão e em testes. */
+declare const noopLogger: Logger;
+/**
+ * Atende por `process.env.SQUORD_LOG` (`debug|info|warn|error`) e cria o
+ * logger padrão. `debug` também é habilitado por `SQUORD_DEBUG=1`.
+ */
+declare function loggerFromEnv(): Logger;
+
+/**
+ * Cliente REST do Squord.
+ *
+ * Encapsula `https://api.squord.com.br/api/v1` com:
+ * - autenticação por token de bot (`Authorization: Bot sqb_...`);
+ * - timeout configurável e cancelamento via `AbortSignal`;
+ * - `x-request-id` em toda requisição (o valor volta nos erros);
+ * - respeito aos limites de taxa: espera `details.retryAfter` em 429,
+ *   observa os headers `X-RateLimit-*` e aplica um teto global conservador;
+ * - retentativas para falhas transitórias (5xx, rede, 429) **somente em
+ *   operações idempotentes ou protegidas por `nonce`** — a regra de ouro:
+ *   nunca repetir automaticamente uma operação sem saber se a primeira foi
+ *   processada;
+ * - erros tipados (veja `../errors`).
+ */
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RestClientOptions {
+    /** URL base da API. Padrão: `https://api.squord.com.br/api/v1`. */
+    baseURL?: string;
+    /** Token do bot (`sqb_...`). O SDK adiciona o prefixo `Bot `. */
+    token: string;
+    /** Timeout por requisição, em milissegundos. Padrão: 15000. */
+    timeoutMs?: number;
+    /**
+     * Retentativas automáticas adicionais para falhas transitórias
+     * (429, 5xx, rede). Padrão: 3.
+     */
+    maxRetries?: number;
+    /**
+     * Teto global de requisições por segundo, abaixo do `BOT_GLOBAL`
+     * oficial (50/s). Padrão: 45. Use `0` para desligar.
+     */
+    globalRequestsPerSecond?: number;
+    /** Implementação de fetch (injetável para testes). Padrão: global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Logger. O SDK não imprime nada por padrão. */
+    logger?: Logger;
+}
+interface RequestOptions {
+    /** Parâmetros de query string (valores `undefined`/`null` são omitidos). */
+    query?: Record<string, string | number | boolean | undefined | null>;
+    /** Corpo JSON da requisição. */
+    body?: unknown;
+    /** Sinal de cancelamento externo. */
+    signal?: AbortSignal;
+    /** Id de requisição para rastreamento (`x-request-id`). */
+    requestId?: string;
+    /**
+     * `false` para rotas públicas, como os callbacks de interação
+     * (`/interactions/{id}/{token}/callback`), que não levam o header
+     * `Authorization`. Padrão: `true`.
+     */
+    auth?: boolean;
+    /**
+     * Se a operação pode ser repetida com segurança após falha incerta
+     * (timeout de rede, 5xx). Padrão: `true` para GET/PUT/DELETE e `false`
+     * para POST. Operações POST protegidas por `nonce` (envio de mensagens,
+     * confirmação de upload) devem marcar `true`.
+     */
+    retryable?: boolean;
+}
+interface RestResponse<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+    requestId: string | null;
+    request: Request;
+}
+/** Headers de rate limit de uma resposta. */
+interface RateLimitState {
+    limit: number | null;
+    remaining: number | null;
+    /** Quando a janela renova, em segundos Unix. */
+    reset: number | null;
+}
+declare class RestClient {
+    readonly baseURL: string;
+    private readonly token;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    private readonly logger;
+    private readonly bucketStates;
+    private readonly bucketBlockedUntil;
+    private readonly globalWindow;
+    private readonly globalLimit;
+    private destroyed;
+    constructor(options: RestClientOptions);
+    /** GET tipado. */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** Implementação de fetch em uso (exposta para uploads e testes). */
+    get fetch(): typeof fetch;
+    /** POST tipado. Não é retentável por padrão. */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** PUT tipado (idempotente). */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** PATCH tipado (retentável por padrão quando idempotente pelo caller). */
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** DELETE tipado. Resposta 204 devolve `null`. */
+    delete<T = null>(path: string, options?: RequestOptions): Promise<T | null>;
+    /** Executa uma requisição com política completa de erros, retries e rate limits. */
+    request<T>(method: HttpMethod, path: string, options?: RequestOptions): Promise<T>;
+    /** Como `request`, mas devolve também status, headers e `x-request-id`. */
+    requestRaw<T>(method: HttpMethod, path: string, options?: RequestOptions): Promise<RestResponse<T>>;
+    /** Encerra o cliente: novas requisições falham imediatamente. */
+    destroy(): void;
+    /** Estado de rate limit conhecido para uma rota (diagnóstico). */
+    bucketState(method: HttpMethod, path: string): RateLimitState | undefined;
+    private buildUrl;
+    private parseBody;
+    private toAPIError;
+    private toNetworkError;
+    private recordBucketState;
+    private waitForRouteBucket;
+    private acquireGlobalSlot;
+}
+/**
+ * Chave de bucket de rate limit: método + caminho com ids substituídos.
+ * Ex.: `POST /channels/{id}/messages` para qualquer canal.
+ */
+declare function routeKeyOf(method: string, path: string): string;
+
+/**
+ * Manager de comandos de aplicação (slash).
+ *
+ * Registrar é uma **sobrescrita em bloco** (`PUT`): a lista enviada substitui
+ * a anterior — comandos fora da lista são apagados; um comando cujo nome
+ * continua mantém o `id`. O padrão é registrar a lista inteira na partida
+ * do bot, sempre a mesma.
+ *
+ * Escopos: global (`PUT /bots/@me/commands`, vale em todos os Spaces do bot)
+ * ou por Space (`PUT /bots/@me/guilds/{guild.id}/commands`). O limite é
+ * `COMMANDS_UPDATE`: 10 sobrescritas por minuto.
+ */
+
+declare class ApplicationCommandsManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Lista os comandos globais do bot. */
+    listGlobal(signal?: AbortSignal): Promise<APICommand[]>;
+    /** Sobrescreve os comandos globais (idempotente por ser PUT). */
+    setGlobal(commands: APICommandInput[], signal?: AbortSignal): Promise<APICommand[]>;
+    /** Lista os comandos de um Space. */
+    listGuild(guildId: Snowflake, signal?: AbortSignal): Promise<APICommand[]>;
+    /** Sobrescreve os comandos de um Space (o bot precisa estar instalado nele). */
+    setGuild(guildId: Snowflake, commands: APICommandInput[], signal?: AbortSignal): Promise<APICommand[]>;
+}
+
+/**
+ * Manager do próprio bot e de usuários.
+ */
+
+declare class BotManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** `GET /bots/@me`: o bot na visão do dono (inclui as intents configuradas). */
+    fetchCurrent(signal?: AbortSignal): Promise<APIBot>;
+    /** `GET /bots/{botId}`: o cartão público de um bot. */
+    fetch(botId: Snowflake, signal?: AbortSignal): Promise<APIBot>;
+}
+declare class UsersManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** `GET /users/@me`: a própria conta (em um bot, campos privados são padrão). */
+    fetchMe(signal?: AbortSignal): Promise<APICurrentUser>;
+}
+
+/**
+ * Manager de canais e threads: consultar, listar a árvore do Space e
+ * criar threads e posts de fórum.
+ */
+
+declare class ChannelsManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Busca um canal (ou uma thread, que também é canal) pelo id. */
+    fetch(channelId: Snowflake, signal?: AbortSignal): Promise<APIChannel>;
+    /**
+     * Lista a árvore de canais do Space: grupos por categoria.
+     * Requer que o bot veja os canais (`VIEW_CHANNEL` do cargo dele).
+     */
+    fetchTree(guildId: Snowflake, signal?: AbortSignal): Promise<APIChannelTreeNode[]>;
+    /** Cria uma thread em um canal de texto ou de anúncios. */
+    createThread(channelId: Snowflake, body: APIThreadCreateBody, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIThread>;
+    /** Cria um post em um canal de fórum (a primeira mensagem vai no corpo). */
+    createForumPost(channelId: Snowflake, body: APIForumPostCreateBody, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIThread>;
+    /** Cria uma thread a partir de uma mensagem de um canal de texto/anúncios. */
+    createThreadFromMessage(channelId: Snowflake, messageId: Snowflake, body: APIThreadCreateBody, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIThread>;
+    /** Lista uma página de threads do canal (`cursor` = `nextCursor` anterior). */
+    listThreads(channelId: Snowflake, params?: APIThreadListParams, signal?: AbortSignal): Promise<APIThreadPage>;
+}
+
+/**
+ * Manager de interações: callback da primeira resposta e follow-ups.
+ *
+ * As rotas são públicas: o token da interação vai no caminho e não se envia
+ * o header `Authorization`. A janela é de **15 minutos**; a primeira resposta
+ * é a única aceita como callback (`409 INTERACTION_ALREADY_ACKNOWLEDGED` na
+ * segunda), e follow-up antes da primeira resposta dá
+ * `409 INTERACTION_NOT_ACKNOWLEDGED`. O limite por interação é de
+ * 5 respostas (callback + follow-ups) a cada 5 segundos.
+ *
+ * O padrão para trabalho demorado é `DEFERRED` + follow-up.
+ */
+
+declare class InteractionsManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /**
+     * Primeira resposta a uma interação (`type`: `MESSAGE`, `DEFERRED`,
+     * `UPDATE` ou `DEFERRED_UPDATE`). Resolve em `204` (sem corpo).
+     *
+     * Não é retentável automaticamente: uma repetição pode encontrar
+     * `409 INTERACTION_ALREADY_ACKNOWLEDGED`. O SDK trata esse 409 como
+     * "resposta já entregue" e resolve sem erro (veja `reply`).
+     */
+    callback(interactionId: string, interactionToken: string, body: APIInteractionCallbackBody, signal?: AbortSignal): Promise<void>;
+    /**
+     * Follow-up depois da primeira resposta. Age como `MESSAGE`: cria uma
+     * mensagem (ou resposta efêmera). Responde `204`.
+     */
+    followup(interactionId: string, interactionToken: string, data: APIInteractionReplyData, signal?: AbortSignal): Promise<void>;
+    /**
+     * Resposta `MESSAGE` com payload conveniente (string ou objeto).
+     * Um `409 INTERACTION_ALREADY_ACKNOWLEDGED` é tratado como sucesso:
+     * significa que a resposta já foi entregue (por exemplo, após um timeout
+     * de rede em que a primeira tentativa chegou ao servidor).
+     */
+    reply(interactionId: string, interactionToken: string, payload: MessagePayloadLike, options?: {
+        ephemeral?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** `DEFERRED`: avisa que o bot está processando ("pensando"). Depois, use follow-ups. */
+    defer(interactionId: string, interactionToken: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** `UPDATE` (só componente): edita a mensagem que tinha o componente clicado. */
+    update(interactionId: string, interactionToken: string, payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** `DEFERRED_UPDATE` (só componente): confirma o clique sem mudar nada. */
+    acknowledgeComponent(interactionId: string, interactionToken: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+
+/**
+ * Manager de Spaces (guilds), membros, cargos e moderação.
+ *
+ * A nomenclatura do SDK usa "Space" na documentação, mas a API chama o
+ * recurso de `guild` (`/guilds/...`), o que o SDK preserva nos caminhos.
+ */
+
+declare class GuildsManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Busca um Space pelo id, com o bloco `self` do bot nele. */
+    fetch(guildId: Snowflake, signal?: AbortSignal): Promise<APIGuild>;
+}
+interface MemberListParams extends CursorPaginationParams {
+    /** Só membros com este cargo. */
+    roleId?: Snowflake;
+    /** Prefixo do `username` ou parte do `displayName`. */
+    search?: string;
+    /** Só membros que enxergam este canal (threads valem pelo canal pai). */
+    channelId?: Snowflake;
+}
+declare class MembersManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Busca um membro de um Space. */
+    fetch(guildId: Snowflake, userId: Snowflake, signal?: AbortSignal): Promise<APIMember>;
+    /** Lista membros com paginação por cursor e filtros. */
+    list(guildId: Snowflake, params?: MemberListParams, signal?: AbortSignal): Promise<APIMemberPage>;
+    /**
+     * Edita um membro: apelido, cargos (substituem o conjunto), timeout,
+     * silenciamento. O bot precisa das permissões correspondentes.
+     */
+    edit(guildId: Snowflake, userId: Snowflake, body: APIMemberEditBody, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIMember>;
+    /** Aplica um timeout até a data informada (`TIMEOUT_MEMBERS`). */
+    timeout(guildId: Snowflake, userId: Snowflake, until: ISODate, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIMember>;
+    /** Remove o timeout de um membro. */
+    removeTimeout(guildId: Snowflake, userId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIMember>;
+    /** Expulsa um membro (`KICK_MEMBERS`). Ele pode voltar com um novo convite. */
+    kick(guildId: Snowflake, userId: Snowflake, reason?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Dá um cargo a um membro (`MANAGE_ROLES`, hierarquia abaixo do bot). */
+    addRole(guildId: Snowflake, userId: Snowflake, roleId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Tira um cargo de um membro. */
+    removeRole(guildId: Snowflake, userId: Snowflake, roleId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+declare class RolesManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Lista os cargos de um Space. */
+    list(guildId: Snowflake, signal?: AbortSignal): Promise<APIRole[]>;
+}
+/** Moderação: banimentos e desbanimentos (por enquanto o que a API expõe a bots). */
+declare class ModerationManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /**
+     * Ban um membro (`BAN_MEMBERS`). Pode apagar até 7 dias de histórico
+     * recente com `deleteMessageSeconds`. Não é retentável por padrão.
+     */
+    ban(guildId: Snowflake, userId: Snowflake, body?: APIMemberBanBody, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIMemberBan>;
+    /** Desbane (`BAN_MEMBERS`). Banimentos da plataforma não podem ser desfeitos. */
+    unban(guildId: Snowflake, userId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+
+/**
+ * Manager de mensagens: enviar, editar, apagar, reagir, fixar e consultar.
+ */
+
+interface SendOptions {
+    /** Anula a requisição. */
+    signal?: AbortSignal;
+    /**
+     * Chave de idempotência da mensagem. Se omitida, o SDK gera uma — o que
+     * torna seguro repetir o envio após falha de rede sem duplicar a mensagem.
+     */
+    nonce?: string;
+}
+declare class MessagesManager {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Busca uma mensagem pelo id. */
+    fetch(channelId: Snowflake, messageId: Snowflake): Promise<APIMessage>;
+    /** Lista uma página do histórico do canal (padrão: 50, máximo 100). */
+    list(channelId: Snowflake, params?: APIMessageListParams, signal?: AbortSignal): Promise<APIMessagePage>;
+    /**
+     * Envia uma mensagem. O SDK anexa um `nonce` automático (idempotência),
+     * então a operação pode ser repetida com segurança pelo cliente REST em
+     * falhas transitórias.
+     */
+    send(channelId: Snowflake, payload: MessagePayloadLike, options?: SendOptions): Promise<APIMessage>;
+    /** Edita uma mensagem (do próprio bot). `embeds`/`components` substituem a lista inteira. */
+    edit(channelId: Snowflake, messageId: Snowflake, payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+    }): Promise<APIMessage>;
+    /** Apaga uma mensagem (própria ou de outros, com `MANAGE_MESSAGES`). Responde 204. */
+    delete(channelId: Snowflake, messageId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Reage a uma mensagem (`ADD_REACTIONS`). `emoji` é o caractere ou `<:nome:id>`. */
+    react(channelId: Snowflake, messageId: Snowflake, emoji: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Remove a reação do bot. */
+    removeReaction(channelId: Snowflake, messageId: Snowflake, emoji: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Lista as reações de uma mensagem. */
+    listReactions(channelId: Snowflake, messageId: Snowflake, signal?: AbortSignal): Promise<APIReaction[]>;
+    /** Fixa uma mensagem no canal (`PIN_MESSAGES`). */
+    pin(channelId: Snowflake, messageId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Desafixa uma mensagem. */
+    unpin(channelId: Snowflake, messageId: Snowflake, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Lista as mensagens fixadas do canal. */
+    listPins(channelId: Snowflake, signal?: AbortSignal): Promise<APIMessage[]>;
+}
+
+/**
+ * Manager de uploads: o fluxo oficial de anexos do Squord.
+ *
+ * Anexos não vão no JSON da mensagem. O fluxo tem três passos:
+ * 1. **Reservar** (`POST /uploads`): devolve o upload e um alvo assinado.
+ * 2. **Enviar os bytes** com `PUT` ao alvo (fora da API do Squord, sem o
+ *    header `Authorization`, repetindo os headers do alvo exatamente).
+ * 3. **Confirmar** (`POST /uploads/{id}/confirm`): o Squord confere o que
+ *    chegou (tipo, tamanho, primeiros bytes). Confirmar de novo devolve o
+ *    mesmo resultado — a rota é idempotente.
+ *
+ * Depois, o `id` do upload entra em `attachmentIds` da mensagem
+ * (até 10 por mensagem; cada upload só entra em uma).
+ *
+ * Nota: `Readable` é consumido em memória antes do `PUT`. Para arquivos
+ * muito grandes, prefira passar o caminho (`path`) e confira o limite do
+ * plano do Space (25 MB no gratuito; o teto da API é 500 MB).
+ */
+
+type UploadSource = Buffer | Uint8Array | string | Readable;
+interface UploadOptions {
+    /** Space do canal onde o anexo será usado. Bots sempre informam. */
+    guildId: Snowflake;
+    /** Nome do arquivo (1 a 256 caracteres). Padrão: nome do caminho. */
+    filename?: string;
+    /** Tipo de conteúdo, ex.: `image/png`. Precisa bater com os bytes. */
+    contentType?: string;
+    /** Caminho local do arquivo. */
+    path?: string;
+    /** Conteúdo em memória ou stream. */
+    data?: UploadSource;
+    /** Tamanho em bytes (obrigatório ao usar stream). */
+    size?: number;
+    /** Anula a operação. */
+    signal?: AbortSignal;
+}
+declare class UploadsManager {
+    private readonly rest;
+    private readonly logger;
+    constructor(rest: RestClient, logger?: Logger);
+    /** Reserva um upload (`POST /uploads`). Não é idempotente. */
+    reserve(body: APIUploadCreateBody, signal?: AbortSignal): Promise<APIUploadReservation>;
+    /** Confirma um upload (`POST /uploads/{id}/confirm`). Idempotente. */
+    confirm(uploadId: Snowflake, body?: APIUploadConfirmBody, signal?: AbortSignal): Promise<APIUpload>;
+    /**
+     * Fluxo completo: reserva, envia os bytes e confirma. Devolve o upload em
+     * `status: "READY"`, pronto para `attachmentIds`.
+     *
+     * Aceita caminho local (`path`), `Buffer`/`Uint8Array` ou `Readable`
+     * (informe `size`). Streams são sempre encerrados, mesmo em falha.
+     */
+    upload(options: UploadOptions): Promise<APIUpload>;
+    /** Atalho: envia um arquivo e devolve o `id` pronto para `attachmentIds`. */
+    uploadForAttachment(options: UploadOptions): Promise<Snowflake>;
+    private collectStream;
+}
+
+/**
+ * Contrato que o `SquordClient` cumpre para as estruturas (evita ciclo de
+ * import em tempo de execução: estruturas importam apenas **tipos** dos
+ * managers; as instâncias vêm do cliente).
+ */
+
+interface ClientLike {
+    readonly rest: RestClient;
+    readonly messages: MessagesManager;
+    readonly channels: ChannelsManager;
+    readonly guilds: GuildsManager;
+    readonly members: MembersManager;
+    readonly roles: RolesManager;
+    readonly moderation: ModerationManager;
+    readonly uploads: UploadsManager;
+    readonly interactions: InteractionsManager;
+    readonly commands: ApplicationCommandsManager;
+    readonly bot: BotManager;
+    readonly users: UsersManager;
+    /** Id da conta do bot (disponível após o login). */
+    readonly userId: SnowflakeLike;
+}
+type SnowflakeLike = string | null;
+/** Base das estruturas: guarda o payload cru e a referência ao cliente. */
+declare class Structure {
+    protected readonly client: ClientLike;
+    /** O payload cru devolvido pela API/gateway. */
+    readonly raw: Record<string, unknown>;
+    constructor(client: ClientLike, 
+    /** O payload cru devolvido pela API/gateway. */
+    raw: Record<string, unknown>);
+}
+
+/**
+ * Estruturas de usuário, membro, cargo e Space.
+ */
+
+/** Conta de usuário (pessoa ou bot). */
+declare class User extends Structure {
+    constructor(client: ClientLike, raw: APIUser);
+    get data(): APIUser;
+    get id(): Snowflake;
+    get username(): string;
+    get displayName(): string;
+    get avatarUrl(): string | null;
+    /** `true` para contas de bot (flag `BOT`). */
+    get isBot(): boolean;
+    /** `true` para bots verificados pelo Squord. */
+    get isVerifiedBot(): boolean;
+    get deleted(): boolean;
+    get suspended(): boolean;
+    /** Menção `<@id>` para usar no conteúdo de mensagens. */
+    get mention(): string;
+    /** Busca o membro correspondente em um Space. */
+    member(guildId: Snowflake): Promise<Member | null>;
+}
+/** Perfil de um usuário dentro de um Space. */
+declare class Member extends Structure {
+    constructor(client: ClientLike, raw: APIMember);
+    get data(): APIMember;
+    /** Id da participação (não confundir com o id da conta). */
+    get id(): Snowflake;
+    get guildId(): Snowflake;
+    get userId(): Snowflake;
+    get user(): User;
+    get nickname(): string | null;
+    /** Nome de exibição efetivo: apelido no Space ou `displayName`. */
+    get displayName(): string;
+    get roleIds(): Snowflake[];
+    get joinedAt(): ISODate;
+    /** `null` ou data futura: enquanto futura, o membro está de castigo. */
+    get timeoutUntil(): ISODate | null;
+    get isTimedOut(): boolean;
+    get isBot(): boolean;
+    get mention(): string;
+    /** Menciona o cargo do membro? Cargos não mencionáveis não notificam. */
+    get mentionNicknameOnly(): string;
+    /** Recarrega o membro da API. */
+    fetch(): Promise<Member>;
+    /** Lista os cargos do membro no Space. */
+    fetchRoles(): Promise<Role[]>;
+    /** Dá um cargo ao membro (respeita hierarquia; cargos gerenciados dão `400 ROLE_MANAGED`). */
+    addRole(roleId: Snowflake): Promise<void>;
+    /** Tira um cargo do membro. */
+    removeRole(roleId: Snowflake): Promise<void>;
+    /** Muda o apelido (`MANAGE_NICKNAMES`, ou `CHANGE_NICKNAME` em si mesmo). */
+    setNickname(nickname: string | null): Promise<Member>;
+    /** Aplica timeout até uma data (`TIMEOUT_MEMBERS`). */
+    timeout(until: ISODate | Date): Promise<Member>;
+    /** Remove o timeout. */
+    removeTimeout(): Promise<Member>;
+    /** Expulsa o membro (`KICK_MEMBERS`). Ele pode voltar com novo convite. */
+    kick(reason?: string): Promise<void>;
+    /** Bane o membro (`BAN_MEMBERS`). */
+    ban(options?: {
+        reason?: string;
+        deleteMessageSeconds?: number;
+    }): Promise<void>;
+}
+/** Um cargo do Space. */
+declare class Role extends Structure {
+    constructor(client: ClientLike, raw: APIRole);
+    get data(): APIRole;
+    get id(): Snowflake;
+    get guildId(): Snowflake;
+    get name(): string;
+    get color(): string | null;
+    get position(): number;
+    /** Bits como `BigInt` (permissões trafegam como string decimal). */
+    get permissions(): bigint;
+    /** Testa se o cargo concede um conjunto de permissões. */
+    has(...flags: bigint[]): boolean;
+    get managed(): boolean;
+    get managedKind(): string | null;
+    get mentionable(): boolean;
+    /** Menção `<@&id>`; só notifica se o cargo for mencionável. */
+    get mention(): string;
+    /** `true` para o cargo @everyone (o id é o próprio id do Space). */
+    get isEveryone(): boolean;
+}
+/** Um Space (comunidade). */
+declare class Guild extends Structure {
+    constructor(client: ClientLike, raw: APIGuild);
+    get data(): APIGuild;
+    get id(): Snowflake;
+    get name(): string;
+    get slug(): string;
+    get ownerId(): Snowflake;
+    get memberCount(): number;
+    get iconUrl(): string | null;
+    get boostCount(): number;
+    /** O bot neste Space: id de participação, cargos e permissões no nível do Space. */
+    get self(): {
+        memberId: Snowflake;
+        roleIds: Snowflake[];
+        permissions: bigint;
+        isOwner: boolean;
+    };
+    /** Testa permissões do bot no nível do Space (overwrites de canal à parte). */
+    botHas(...flags: bigint[]): boolean;
+    /** Recarrega o Space. */
+    fetch(): Promise<Guild>;
+    /** Árvore de canais do Space, agrupada por categorias. */
+    fetchChannelTree(): Promise<ChannelTreeGroup[]>;
+    /** Lista os cargos do Space. */
+    fetchRoles(): Promise<Role[]>;
+    /** Busca um membro pelo id da conta. */
+    fetchMember(userId: Snowflake): Promise<Member>;
+}
+/** Grupo da árvore de canais (categoria e seus canais). */
+interface ChannelTreeGroup {
+    category: Channel | null;
+    channels: Channel[];
+}
+
+/**
+ * Estrutura de mensagem: leitura e ações de alto nível
+ * (responder, editar, apagar, reagir, fixar, abrir thread).
+ */
+
+declare class Message extends Structure {
+    constructor(client: ClientLike, raw: APIMessage);
+    get data(): APIMessage;
+    get id(): Snowflake;
+    get guildId(): Snowflake | null;
+    get channelId(): Snowflake;
+    get authorId(): Snowflake;
+    get author(): User;
+    get type(): MessageType;
+    get content(): string;
+    get replyToId(): Snowflake | null;
+    get pinned(): boolean;
+    get editedAt(): ISODate | null;
+    get moderated(): boolean;
+    get attachments(): APIMessage["attachments"];
+    get embeds(): APIMessage["embeds"];
+    get components(): APIMessage["components"];
+    get reactions(): APIReaction[];
+    get createdAt(): ISODate;
+    /** Apelido do autor no Space (quando houver). */
+    get memberNickname(): string | null;
+    /** Nome de exibição efetivo do autor (apelido ou displayName). */
+    get authorDisplayName(): string;
+    /** `true` se a mensagem veio do próprio bot. */
+    get fromMe(): boolean;
+    /** `true` se o bot foi mencionado (`<@id>` no conteúdo). */
+    get mentionsMe(): boolean;
+    /** Ids mencionados na mensagem (só as menções que valeram). */
+    get mentionedUserIds(): Snowflake[];
+    get mentionedRoleIds(): Snowflake[];
+    get mentionsEveryone(): boolean;
+    /** Recarrega a mensagem (ela pode ter sido apagada; isso lança 404). */
+    fetch(): Promise<Message>;
+    /** Busca o canal da mensagem (uma thread também é canal). */
+    fetchChannel(): Promise<Channel | Thread | null>;
+    /** Responde a mensagem (usa `replyToId`). Idempotente por `nonce`. */
+    reply(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+        nonce?: string;
+    }): Promise<Message>;
+    /** Edita a mensagem (só mensagens do próprio bot). */
+    edit(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+    }): Promise<Message>;
+    /** Apaga a mensagem (a do bot sempre; de outros, com `MANAGE_MESSAGES`). */
+    delete(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Reage com um emoji Unicode ou `<:nome:id>`. */
+    react(emoji: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Remove a reação do bot. */
+    removeReaction(emoji: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Fixa a mensagem no canal (`PIN_MESSAGES`). */
+    pin(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Desafixa a mensagem. */
+    unpin(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Cria uma thread a partir desta mensagem (canais de texto e anúncios). */
+    startThread(body: {
+        name: string;
+        autoArchiveMinutes?: ThreadAutoArchiveMinutes;
+    }): Promise<Thread>;
+}
+
+/**
+ * Estruturas de canal e thread.
+ *
+ * Uma thread também é canal: use o `id` dela como `channelId` nas rotas
+ * de mensagem. Threads não têm overwrites: vale o canal pai.
+ */
+
+/** Um canal de texto, anúncios, categoria, fórum, voz ou palco. */
+declare class Channel extends Structure {
+    constructor(client: ClientLike, raw: APIChannel);
+    get data(): APIChannel;
+    get id(): Snowflake;
+    get guildId(): Snowflake;
+    get name(): string;
+    get type(): ChannelType;
+    get topic(): string | null;
+    get categoryId(): Snowflake | null;
+    get isPrivate(): boolean;
+    /** Modo lento em segundos (0 desligado). */
+    get rateLimitPerUser(): number;
+    get chatEnabled(): boolean;
+    get lastMessageId(): Snowflake | null;
+    /** Menção `<#id>`. */
+    get mention(): string;
+    get isText(): boolean;
+    get isVoice(): boolean;
+    get isForum(): boolean;
+    /** Recarrega o canal. */
+    fetch(): Promise<Channel>;
+    /** Envia uma mensagem no canal (idempotente por `nonce`). */
+    send(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+        nonce?: string;
+    }): Promise<Message>;
+    /** Envia um arquivo como anexo do canal (fluxo completo de upload). */
+    sendFile(options: {
+        path?: string;
+        data?: Buffer | Uint8Array;
+        filename?: string;
+        contentType?: string;
+    }, content?: string): Promise<Message>;
+    /** Busca uma mensagem do canal pelo id. */
+    fetchMessage(messageId: Snowflake): Promise<Message>;
+    /** Lista uma página do histórico (use `client.paginate` para iterar tudo). */
+    fetchMessages(params?: {
+        limit?: number;
+        before?: string;
+        after?: string;
+    }): Promise<{
+        items: Message[];
+        hasMore: boolean;
+        prevCursor: string | null;
+        nextCursor: string | null;
+    }>;
+    /** Mensagens fixadas do canal. */
+    fetchPins(): Promise<Message[]>;
+    /** Cria uma thread neste canal (texto/anúncios) ou um post (fórum). */
+    createThread(body: APIThreadCreateBody): Promise<Thread>;
+    /** Lista as threads do canal (`cursor` = `nextCursor` da página anterior). */
+    fetchThreads(params?: {
+        limit?: number;
+        cursor?: string;
+        archived?: "true" | "false";
+        tagId?: Snowflake;
+    }): Promise<{
+        items: Thread[];
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+}
+/** Uma thread ou post de fórum. */
+declare class Thread extends Structure {
+    constructor(client: ClientLike, raw: APIThread);
+    get data(): APIThread;
+    get id(): Snowflake;
+    get guildId(): Snowflake;
+    get parentId(): Snowflake;
+    get name(): string;
+    get ownerId(): Snowflake;
+    get isForumPost(): boolean;
+    get archived(): boolean;
+    get locked(): boolean;
+    get autoArchiveMinutes(): ThreadAutoArchiveMinutes;
+    get messageCount(): number;
+    get lastMessageId(): Snowflake | null;
+    get lastMessageAt(): ISODate;
+    get appliedTagIds(): Snowflake[];
+    get mention(): string;
+    /** Envia uma mensagem na thread (usa o id dela como channelId). */
+    send(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+        nonce?: string;
+    }): Promise<Message>;
+    /** Busca uma mensagem da thread. */
+    fetchMessage(messageId: Snowflake): Promise<Message>;
+}
+
+/**
+ * Estrutura de interação: um comando de barra usado ou um clique em
+ * componente de mensagem do bot.
+ *
+ * O bot responde em até ~10 segundos (o app avisa "não respondeu" depois
+ * disso); use `defer()` e follow-ups para trabalho demorado. A janela total
+ * de resposta é de 15 minutos, e o limite é de 5 respostas a cada 5 segundos
+ * por interação.
+ */
+
+declare class Interaction extends Structure {
+    constructor(client: ClientLike, raw: APIInteraction);
+    get data(): APIInteraction;
+    get id(): string;
+    /** Credencial da interação (15 minutos de validade). Trate como segredo. */
+    get token(): string;
+    get type(): "COMMAND" | "COMPONENT";
+    get guildId(): Snowflake;
+    get channelId(): Snowflake;
+    /** Quem invocou o comando ou clicou no componente. */
+    get user(): User;
+    /** O membro que invocou (com cargos do Space), quando disponível. */
+    get member(): Member | null;
+    get createdAt(): string;
+    get isCommand(): boolean;
+    get isComponent(): boolean;
+    /** Dados do comando (presentes quando `isCommand`). */
+    get command(): APIInteractionCommandData | null;
+    /** Dados do componente (presentes quando `isComponent`). */
+    get component(): APIInteractionComponentData | null;
+    /** O `customId` do componente clicado (ou `null`). */
+    get customId(): string | null;
+    /** Os valores escolhidos em um menu (vazio em botões). */
+    get values(): string[];
+    /** Lista as opções preenchidas da invocação (já validadas pelo Squord). */
+    get options(): Array<{
+        name: string;
+        type: CommandOptionType;
+        value: string | number | boolean;
+    }>;
+    /** Valor bruto de uma opção pelo nome. */
+    getOption(name: string): string | number | boolean | undefined;
+    /** Opção `STRING`. */
+    getString(name: string, required?: boolean): string | undefined;
+    /** Opção `INTEGER`. */
+    getInteger(name: string, required?: boolean): number | undefined;
+    /** Opção `BOOLEAN`. */
+    getBoolean(name: string, required?: boolean): boolean | undefined;
+    /** Opção `USER`/`CHANNEL`/`ROLE`: o valor é o id (string). */
+    getId(name: string, required?: boolean): Snowflake | undefined;
+    /** Primeira resposta como mensagem. `ephemeral: true` mostra só para quem invocou. */
+    reply(payload: MessagePayloadLike, options?: {
+        ephemeral?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Resposta efêmera: só quem invocou vê; não é salva; só botões de link. */
+    replyEphemeral(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** `DEFERRED`: mostra o bot "pensando" enquanto o trabalho roda. */
+    defer(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * `UPDATE` (só componente): edita a mensagem que tinha o componente.
+     * O caso típico: marcar a escolha, mudar de página.
+     */
+    update(payload: MessagePayloadLike, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** `DEFERRED_UPDATE` (só componente): confirma o clique sem mudar nada. */
+    acknowledge(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Follow-up: mensagem extra depois da primeira resposta
+     * (o padrão para trabalho demorado é `defer()` + follow-up).
+     */
+    followup(payload: MessagePayloadLike, options?: {
+        ephemeral?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Busca a mensagem do componente clicado (quando `isComponent`). */
+    fetchComponentMessage(): Promise<Message | null>;
+}
+
+/**
+ * Tipos do protocolo do gateway do Squord.
+ *
+ * Referência: https://docs.squord.com.br/gateway/visao-geral
+ *
+ * Todo frame é um objeto JSON em texto UTF-8. Os frames enviados pelo bot têm
+ * `{ op, d, requestId? }`; os recebidos têm `{ op, d, timestamp, ... }`.
+ */
+
+/** Opcodes que o bot pode enviar. */
+type ClientOpcode = "identify" | "resume" | "heartbeat" | "presence.update" | "subscribe" | "unsubscribe" | "typing.start" | "voice.state.update";
+/** Opcodes que o servidor envia. */
+type ServerOpcode = "hello" | "ready" | "resumed" | "heartbeat.ack" | "invalid_session" | "reconnect" | "error" | "event";
+/** `hello`: o primeiro frame, assim que a conexão é aceita. */
+interface GatewayHello {
+    heartbeatIntervalMs: number;
+    sessionId: string;
+    protocolVersion: number;
+}
+/** `ready`: resposta ao `identify`. */
+interface GatewayReady {
+    sessionId: string;
+    /** Id da conta do bot (igual ao id do bot). */
+    userId: Snowflake;
+    /** Spaces onde o bot está instalado: `id`, `name`, `iconUrl`. */
+    guilds: Array<{
+        id: Snowflake;
+        name: string;
+        iconUrl: string | null;
+    }>;
+    resumeGatewayUrl: string;
+}
+/** `resumed`: resposta ao `resume` (os eventos perdidos chegam antes dele). */
+interface GatewayResumed {
+    sessionId: string;
+    replayed: number;
+    sequence: number;
+}
+/** `invalid_session`: o `resume` foi recusado; a conexão continua aberta. */
+interface GatewayInvalidSession {
+    resumable: boolean;
+}
+/** `reconnect`: o servidor pediu reconexão; seguido do fechamento 4007. */
+interface GatewayReconnect {
+    reason: string;
+    resumable: boolean;
+}
+/** `error`: um frame foi recusado sem fechar a conexão. */
+interface GatewayError$1 {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+type PresenceStatus = "ONLINE" | "IDLE" | "DND" | "INVISIBLE";
+/** Corpo do `presence.update`. */
+interface GatewayPresenceUpdate {
+    status?: PresenceStatus;
+    /** Até 128 caracteres; `null` apaga. */
+    customStatus?: string | null;
+    afk?: boolean;
+}
+/** Um frame `event` recebido do gateway. */
+interface GatewayEventFrame<T = unknown> {
+    op: "event";
+    type: string;
+    d: T;
+    /** Sequência da sessão; cresce de um em um. Só em eventos duráveis. */
+    s?: number;
+    timestamp: number;
+}
+/** Qualquer frame recebido do servidor. */
+type ServerFrame = (GatewayEventFrame & {
+    requestId?: string;
+}) | ({
+    op: "hello";
+    d: GatewayHello;
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "ready";
+    d: GatewayReady;
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "resumed";
+    d: GatewayResumed;
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "heartbeat.ack";
+    d: {
+        sequence: number;
+    };
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "invalid_session";
+    d: GatewayInvalidSession;
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "reconnect";
+    d: GatewayReconnect;
+    timestamp: number;
+    requestId?: string;
+}) | ({
+    op: "error";
+    d: GatewayError$1;
+    timestamp: number;
+    requestId?: string;
+});
+declare const GatewayCloseCodes: {
+    readonly UnknownError: 4000;
+    readonly UnknownOpcode: 4001;
+    readonly DecodeError: 4002;
+    readonly NotAuthenticated: 4003;
+    readonly AuthenticationFailed: 4004;
+    readonly AlreadyAuthenticated: 4005;
+    readonly InvalidSequence: 4007;
+    readonly RateLimited: 4008;
+    readonly SessionTimeout: 4009;
+    readonly InvalidProtocolVersion: 4012;
+    readonly AccountSuspended: 4013;
+    readonly BotSessionLimit: 4014;
+};
+type GatewayCloseCode = (typeof GatewayCloseCodes)[keyof typeof GatewayCloseCodes];
+/** Eventos duráveis entregues pelo gateway (campo `type` do frame `event`). */
+type GatewayEventName = "message.created" | "message.updated" | "message.deleted" | "message.bulk_deleted" | "poll.vote.cast" | "poll.vote.removed" | "reaction.added" | "reaction.removed" | "member.joined" | "member.updated" | "member.left" | "member.banned" | "member.unbanned" | "guild.updated" | "guild.deleted" | "guild.taken_down" | "guild.boost.added" | "guild.boost.removed" | "channel.created" | "channel.updated" | "channel.deleted" | "channel.tree.invalidated" | "role.created" | "role.updated" | "role.deleted" | "thread.created" | "thread.updated" | "thread.deleted" | "emoji.created" | "emoji.updated" | "emoji.deleted" | "sticker.created" | "sticker.updated" | "sticker.deleted" | "guild_event.created" | "guild_event.updated" | "guild_event.deleted" | "announcement.follow.created" | "announcement.follow.deleted" | "voice.state.updated" | "voice.room.updated" | "voice.member.moved" | "voice.e2ee.bot_key_requested" | "interaction.created" | "application_command.updated";
+interface PollResults {
+    voterCount: number;
+    answers: Array<{
+        answerId: Snowflake;
+        count: number;
+    }>;
+}
+interface PollVotePayload {
+    messageId: Snowflake;
+    channelId: Snowflake;
+    guildId: Snowflake | null;
+    userId: Snowflake;
+    results: PollResults;
+}
+interface ReactionAddedPayload {
+    messageId: Snowflake;
+    channelId: Snowflake;
+    guildId: Snowflake | null;
+    userId: Snowflake;
+    /** A reação após a mudança. O `me` não é confiável num evento. */
+    reaction: {
+        emoji: string;
+        count: number;
+        userIds: Snowflake[];
+        me: boolean;
+    };
+    /** Emoji customizado resolvido; `null` para emoji padrão. */
+    customEmoji: {
+        id: Snowflake;
+        name: string;
+        animated: boolean;
+        url: string;
+    } | null;
+}
+interface ReactionRemovedPayload {
+    messageId: Snowflake;
+    channelId: Snowflake;
+    guildId: Snowflake | null;
+    userId: Snowflake;
+    emoji: string;
+}
+interface MessageDeletedPayload {
+    messageId: Snowflake;
+    channelId: Snowflake;
+    guildId: Snowflake | null;
+    /** Só quando o delete apagou a mensagem mais nova do canal. */
+    lastMessageId?: Snowflake | null;
+}
+interface MessageBulkDeletedPayload {
+    messageIds: Snowflake[];
+    channelId: Snowflake;
+    guildId: Snowflake | null;
+    lastMessageId?: Snowflake | null;
+}
+interface MemberLeftPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+}
+interface MemberBannedPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    reason: string | null;
+}
+interface MemberUnbannedPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+}
+interface GuildDeletedPayload {
+    guildId: Snowflake;
+}
+interface GuildTakenDownPayload {
+    guildId: Snowflake;
+    name: string;
+}
+interface GuildBoostPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    boostIds: Snowflake[];
+    boostCount: number;
+    boostLevel: number;
+    previousLevel: number;
+    /** Só em `guild.boost.removed`. */
+    reason?: "REMOVED" | "MOVED" | "LEFT" | "LAPSED" | "SPACE_GONE" | "OPERATOR";
+}
+interface ChannelDeletedPayload {
+    channelId: Snowflake;
+    guildId: Snowflake;
+}
+interface ChannelTreeInvalidatedPayload {
+    guildId: Snowflake;
+}
+interface RoleDeletedPayload {
+    roleId: Snowflake;
+    guildId: Snowflake;
+}
+interface ThreadDeletedPayload {
+    threadId: Snowflake;
+    parentId: Snowflake;
+    guildId: Snowflake;
+}
+interface EmojiPayload {
+    emoji: {
+        id: Snowflake;
+        guildId: Snowflake;
+        name: string;
+        url: string;
+        creatorId: Snowflake | null;
+        animated: boolean;
+        roleIds: Snowflake[];
+        available: boolean;
+        createdAt: string;
+        updatedAt: string;
+    };
+}
+interface EmojiDeletedPayload {
+    emojiId: Snowflake;
+    guildId: Snowflake;
+}
+interface StickerPayload {
+    sticker: {
+        id: Snowflake;
+        guildId: Snowflake;
+        name: string;
+        description: string | null;
+        tags: string;
+        url: string;
+        format: string;
+        animated: boolean;
+        available: boolean;
+        creatorId: Snowflake | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+}
+interface StickerDeletedPayload {
+    stickerId: Snowflake;
+    guildId: Snowflake;
+}
+interface GuildEventPayload {
+    event: {
+        id: Snowflake;
+        guildId: Snowflake;
+        name: string;
+        description: string | null;
+        startsAt: string;
+        endsAt: string | null;
+        channelId: Snowflake | null;
+        location: string | null;
+        coverUrl: string | null;
+        recurrence: Record<string, unknown> | null;
+        earlyReminderMinutes: number | null;
+        status: "SCHEDULED" | "ACTIVE" | "COMPLETED" | "CANCELED";
+        creatorId: Snowflake | null;
+        interestedCount: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+}
+interface GuildEventDeletedPayload {
+    eventId: Snowflake;
+    guildId: Snowflake;
+}
+interface AnnouncementFollowCreatedPayload {
+    /** Na origem: o seguidor. No destino: o vínculo. Uma das formas chega. */
+    follower?: {
+        id: Snowflake;
+        sourceChannelId: Snowflake;
+        guild: {
+            id: Snowflake;
+            name: string;
+            iconUrl: string | null;
+        };
+        createdAt: string;
+    };
+    follow?: {
+        id: Snowflake;
+        targetChannelId: Snowflake;
+        targetGuildId: Snowflake;
+        source: {
+            id: Snowflake;
+            name: string;
+            iconUrl: string | null;
+        };
+        createdBy: Snowflake;
+        createdAt: string;
+    };
+}
+interface AnnouncementFollowDeletedPayload {
+    followId: Snowflake;
+    sourceChannelId: Snowflake;
+    targetChannelId?: Snowflake;
+}
+interface VoiceState {
+    userId: Snowflake;
+    guildId: Snowflake | null;
+    channelId: Snowflake;
+    sessionId: string;
+    serverMute: boolean;
+    serverDeaf: boolean;
+    selfMute: boolean;
+    selfDeaf: boolean;
+    selfVideo: boolean;
+    selfScreenShare: boolean;
+    watchingUserId: Snowflake | null;
+    suppressed: boolean;
+    joinedAt: string;
+    connectedAt: string | null;
+}
+interface VoiceStateUpdatedPayload {
+    /** `null` quando a pessoa saiu da sala. */
+    state: VoiceState | null;
+    userId: Snowflake;
+    channelId: Snowflake;
+}
+interface VoiceRoomUpdatedPayload {
+    room: {
+        channelId: Snowflake;
+        participants: Array<{
+            state: VoiceState;
+            user: APIUser;
+        }>;
+        hasScreenShare: boolean;
+        hasVideo: boolean;
+    };
+}
+interface VoiceMemberMovedPayload {
+    userId: Snowflake;
+    guildId: Snowflake;
+    fromChannelId: Snowflake;
+    toChannelId: Snowflake;
+    state: VoiceState;
+}
+interface VoiceBotKeyRequestedPayload {
+    channelId: Snowflake;
+    recipients: Array<{
+        userId: Snowflake;
+        publicKey: string;
+    }>;
+}
+interface ApplicationCommandUpdatedPayload {
+    guildId: Snowflake;
+    botId: Snowflake;
+}
+
+/**
+ * Mapa de eventos do `SquordClient`.
+ *
+ * Os eventos seguem os nomes reais do gateway do Squord (`message.created`,
+ * `member.joined`, ...) — a documentação da plataforma é a referência de
+ * quando cada um chega e qual intent ele exige. Eventos desconhecidos do
+ * protocolo chegam em `unknownEvent`, garantindo compatibilidade futura.
+ */
+
+/** Payload do evento `ready` do cliente. */
+interface ReadyEvent {
+    /** A conta do bot. */
+    user: User;
+    /** Id da sessão do gateway (guarde para retomar). */
+    sessionId: string;
+    /** Spaces onde o bot está instalado no momento do ready. */
+    guilds: Array<{
+        id: Snowflake;
+        name: string;
+        iconUrl: string | null;
+    }>;
+    /** Latência já medida, se houver. */
+    ping: number | null;
+}
+interface ClientEvents extends Record<string, unknown> {
+    /** Sessão pronta: o bot autenticou e está online. */
+    ready: ReadyEvent;
+    /** Sessão retomada após queda: os eventos perdidos já chegaram antes. */
+    resumed: GatewayResumed;
+    /** Vai reconectar (backoff com jitter). */
+    reconnecting: {
+        attempt: number;
+        delayMs: number;
+        closeCode: number | null;
+        reason: string;
+    };
+    /** Conexão caiu (com `fatal: true` quando não há retomada). */
+    disconnect: {
+        code: number | null;
+        reason: string;
+        fatal: boolean;
+    };
+    /** Erro de handler, de rede ou de protocolo. */
+    error: Error;
+    /** Avisos não fatais. */
+    warn: string;
+    /** Erro em um handler de comando registrado via `CommandRegistry`. */
+    commandError: {
+        error: unknown;
+        command?: string;
+        message?: Message;
+        interaction?: Interaction;
+    };
+    /** Qualquer frame recebido do gateway (payload cru). */
+    raw: ServerFrame;
+    /** Evento do gateway com payload já hidratado em estruturas. */
+    "message.created": Message;
+    "message.updated": Message;
+    "message.deleted": MessageDeletedPayload;
+    "message.bulk_deleted": MessageBulkDeletedPayload;
+    "poll.vote.cast": PollVotePayload;
+    "poll.vote.removed": PollVotePayload;
+    "reaction.added": ReactionAddedPayload;
+    "reaction.removed": ReactionRemovedPayload;
+    "member.joined": {
+        guildId: Snowflake;
+        member: Member;
+    };
+    "member.updated": {
+        guildId: Snowflake;
+        member: Member;
+    };
+    "member.left": MemberLeftPayload;
+    "member.banned": MemberBannedPayload;
+    "member.unbanned": MemberUnbannedPayload;
+    "guild.updated": Guild;
+    "guild.deleted": GuildDeletedPayload;
+    "guild.taken_down": GuildTakenDownPayload;
+    "guild.boost.added": GuildBoostPayload;
+    "guild.boost.removed": GuildBoostPayload;
+    "channel.created": Channel;
+    "channel.updated": Channel;
+    "channel.deleted": ChannelDeletedPayload;
+    "channel.tree.invalidated": ChannelTreeInvalidatedPayload;
+    "role.created": Role;
+    "role.updated": Role;
+    "role.deleted": RoleDeletedPayload;
+    "thread.created": Thread;
+    "thread.updated": Thread;
+    "thread.deleted": ThreadDeletedPayload;
+    "emoji.created": EmojiPayload;
+    "emoji.updated": EmojiPayload;
+    "emoji.deleted": EmojiDeletedPayload;
+    "sticker.created": StickerPayload;
+    "sticker.updated": StickerPayload;
+    "sticker.deleted": StickerDeletedPayload;
+    "guild_event.created": GuildEventPayload;
+    "guild_event.updated": GuildEventPayload;
+    "guild_event.deleted": GuildEventDeletedPayload;
+    "announcement.follow.created": AnnouncementFollowCreatedPayload;
+    "announcement.follow.deleted": AnnouncementFollowDeletedPayload;
+    "voice.state.updated": VoiceStateUpdatedPayload;
+    "voice.room.updated": VoiceRoomUpdatedPayload;
+    "voice.member.moved": VoiceMemberMovedPayload;
+    "voice.e2ee.bot_key_requested": VoiceBotKeyRequestedPayload;
+    "interaction.created": Interaction;
+    "application_command.updated": ApplicationCommandUpdatedPayload;
+    /** Evento conhecido sem estrutura dedicada, com payload cru. */
+    unknownEvent: {
+        type: string;
+        d: unknown;
+        s?: number;
+        timestamp: number;
+    };
+}
+
+/**
+ * Abstração mínima de WebSocket usada pelo gateway.
+ *
+ * O SDK usa o `WebSocket` global do Node.js (22+) por padrão e aceita
+ * qualquer implementação compatível — inclusive o pacote `ws` e os mocks
+ * de teste (`@squord/sdk/testing`).
+ */
+interface WebSocketCloseEvent {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+interface WebSocketHandlers {
+    open: () => void;
+    message: (data: string) => void;
+    close: (event: WebSocketCloseEvent) => void;
+    error: (error: unknown) => void;
+}
+interface WebSocketLike {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    readonly readyState: number;
+}
+type WebSocketFactory = (url: string) => unknown;
+/** Envelopa a implementação escolhida e normaliza os eventos. */
+declare function attachWebSocket(ws: unknown, handlers: WebSocketHandlers): WebSocketLike;
+
+/**
+ * Gateway do Squord: WebSocket que entrega eventos em tempo real.
+ *
+ * Ciclo de vida (https://docs.squord.com.br/gateway/visao-geral):
+ * 1. Abre a conexão; o servidor envia `hello` (intervalo de heartbeat).
+ * 2. O bot envia `identify` com o token em até 15 segundos.
+ * 3. O servidor responde `ready`; os eventos passam a chegar.
+ * 4. O bot envia `heartbeat` a cada `heartbeatIntervalMs`; o servidor responde
+ *    `heartbeat.ack`. Sem ack dentro de um intervalo, a conexão é considerada
+ *    zumbi e é refeita com `resume`.
+ * 5. Após uma queda, o bot reconecta e envia `resume` com a última sequência;
+ *    o servidor reenvia os eventos perdidos e depois envia `resumed`. Se não
+ *    puder retomar, responde `invalid_session` na mesma conexão, e o bot faz
+ *    `identify` de novo.
+ *
+ * Códigos de fechamento seguem a tabela oficial: 4004/4013/4014 não são
+ * retomáveis; 4001/4002/4005/4012 são erros do bot; os demais reconectam com
+ * backoff exponencial e jitter, tentando `resume`.
+ */
+
+type GatewayStatus = "idle" | "connecting" | "ready" | "reconnecting" | "disconnected" | "destroyed";
+interface GatewayEvents extends Record<string, unknown> {
+    ready: GatewayReady;
+    resumed: GatewayResumed;
+    reconnecting: {
+        attempt: number;
+        delayMs: number;
+        closeCode: number | null;
+        reason: string;
+    };
+    disconnect: {
+        code: number | null;
+        reason: string;
+        fatal: boolean;
+    };
+    invalidSession: GatewayInvalidSession;
+    serverError: GatewayError$1;
+    raw: ServerFrame;
+    event: {
+        type: string;
+        d: unknown;
+        s?: number;
+        timestamp: number;
+    };
+    error: Error;
+    statusChange: GatewayStatus;
+}
+interface GatewayOptions {
+    /** URL do gateway. Padrão: `wss://gateway.squord.com.br/gateway`. */
+    url?: string;
+    /** Token do bot (`sqb_...`), sem prefixo. */
+    token: string;
+    /** Fábrica de WebSocket (injetável para testes). Padrão: `WebSocket` global. */
+    ws?: WebSocketFactory;
+    /** Tempo máximo esperando `ready`/`resumed` após o `identify`/`resume`. Padrão: 20000 ms. */
+    handshakeTimeoutMs?: number;
+    /** `false` para não reconectar automaticamente. */
+    autoReconnect?: boolean;
+    /** Base do backoff de reconexão, em ms. Padrão: 1000 (dobra até 60000). */
+    reconnectBaseMs?: number;
+    /** Logger. */
+    logger?: Logger;
+}
+declare class Gateway extends TypedEmitter<GatewayEvents> {
+    readonly url: string;
+    private readonly token;
+    private readonly wsFactory;
+    private readonly handshakeTimeoutMs;
+    private readonly autoReconnect;
+    private readonly reconnectBaseMs;
+    private readonly logger;
+    private ws;
+    private statusValue;
+    private reconnectAttempts;
+    private connectLoop;
+    private sessionId;
+    private resumeUrl;
+    private lastSequence;
+    private established;
+    private handshake;
+    private handshakeTimer;
+    private heartbeatIntervalMs;
+    private heartbeatTimer;
+    private awaitingAck;
+    private lastHeartbeatSentAt;
+    private destroyed;
+    private closingByClient;
+    private reconnectRequested;
+    /** Latência do gateway: último heartbeat até o ack, em ms. */
+    heartbeatLatencyMs: number | null;
+    /** Quantas reconexões ocorreram desde a criação. */
+    reconnectCount: number;
+    /** Quantos frames de evento foram recebidos (incluindo duplicados). */
+    eventsReceived: number;
+    /** Quantos eventos foram descartados como duplicados. */
+    eventsDropped: number;
+    get sequence(): number | null;
+    get session(): string | null;
+    get status(): GatewayStatus;
+    get isReady(): boolean;
+    constructor(options: GatewayOptions);
+    /**
+     * Conecta ao gateway e resolve quando a sessão está pronta
+     * (`ready` ou `resumed`). Em quedas transitórias, segue tentando com
+     * backoff — a promise só é rejeitada em erros não retomáveis
+     * (token inválido/revogado, conta suspensa, sessões demais, erro de
+     * protocolo) ou se o gateway for destruído.
+     */
+    connect(): Promise<GatewayReady>;
+    /** Envia `presence.update`. O status escolhido vale também nas próximas conexões. */
+    setPresence(presence: GatewayPresenceUpdate): void;
+    /** Fecha a conexão, encerra as reconexões e descarta o estado de sessão. */
+    destroy(): Promise<void>;
+    /** Descarta o estado de sessão: a próxima conexão fará `identify` limpo. */
+    invalidateSession(): void;
+    /** Força uma reconexão imediata (que tentará `resume`). */
+    reconnectNow(): void;
+    private runConnectLoop;
+    /** Abre um socket e resolve no `ready`/`resumed` (handshake completo). */
+    private openSocketOnce;
+    private resolveHandshake;
+    private failHandshake;
+    private clearHandshakeTimer;
+    private handleMessage;
+    private handleHello;
+    private handleReady;
+    private handleResumed;
+    private handleHeartbeatAck;
+    private handleInvalidSession;
+    private handleReconnectRequest;
+    private handleServerError;
+    private handleEvent;
+    private handleClose;
+    private kickReconnectAfterDrop;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendHeartbeat;
+    private sendFrame;
+    private setStatus;
+}
+
+/**
+ * Permissões do Squord.
+ *
+ * Permissões são bits de um número inteiro de 64 bits. Trafegam como
+ * **string decimal** e devem ser calculadas com `BigInt`: os bits mais
+ * altos passam de 2^53, e um `number` de JavaScript perde precisão.
+ *
+ * @see https://docs.squord.com.br/referencia/permissoes
+ */
+
+/** Flags de permissão. O bit 32 (`VIEW_AUDIT_LOG`) está na tabela oficial. */
+declare const Permissions: {
+    readonly VIEW_CHANNEL: bigint;
+    readonly MANAGE_CHANNELS: bigint;
+    readonly MANAGE_GUILD: bigint;
+    readonly MANAGE_ROLES: bigint;
+    readonly MANAGE_INVITES: bigint;
+    readonly VIEW_AUDIT_LOG: bigint;
+    readonly MANAGE_EMOJIS: bigint;
+    readonly MANAGE_WEBHOOKS: bigint;
+    readonly KICK_MEMBERS: bigint;
+    readonly BAN_MEMBERS: bigint;
+    readonly TIMEOUT_MEMBERS: bigint;
+    readonly CHANGE_NICKNAME: bigint;
+    readonly MANAGE_NICKNAMES: bigint;
+    readonly SEND_MESSAGES: bigint;
+    readonly READ_MESSAGE_HISTORY: bigint;
+    readonly MANAGE_MESSAGES: bigint;
+    readonly ATTACH_FILES: bigint;
+    readonly EMBED_LINKS: bigint;
+    readonly ADD_REACTIONS: bigint;
+    readonly MENTION_EVERYONE: bigint;
+    readonly USE_EXTERNAL_EMOJIS: bigint;
+    readonly PIN_MESSAGES: bigint;
+    readonly CONNECT: bigint;
+    readonly SPEAK: bigint;
+    readonly VIDEO: bigint;
+    readonly STREAM: bigint;
+    readonly MUTE_MEMBERS: bigint;
+    readonly DEAFEN_MEMBERS: bigint;
+    readonly MOVE_MEMBERS: bigint;
+    readonly PRIORITY_SPEAKER: bigint;
+    readonly ADMINISTRATOR: bigint;
+    readonly SEND_POLLS: bigint;
+    /** O bit 32 foi aposentado e nunca é reutilizado. */
+    readonly CREATE_INVITE: bigint;
+    readonly APPROVE_JOIN_REQUESTS: bigint;
+    readonly FORWARD_MESSAGES: bigint;
+    readonly HANDLE_REPORTS: bigint;
+    readonly PUBLISH_ANNOUNCEMENTS: bigint;
+    readonly BYPASS_SLOWMODE: bigint;
+    readonly CREATE_THREADS: bigint;
+    readonly SEND_MESSAGES_IN_THREADS: bigint;
+    readonly MANAGE_THREADS: bigint;
+    readonly MANAGE_EVENTS: bigint;
+};
+type PermissionFlag = keyof typeof Permissions;
+/** Todas as permissões, somadas. */
+declare const ALL_PERMISSIONS: bigint;
+/** Converte bits para string decimal (o formato aceito pela API). */
+declare function permissionsToString(bits: bigint): PermissionBits;
+/** Lê uma string decimal vinda da API como `BigInt`. */
+declare function parsePermissions(value: PermissionBits | string): bigint;
+/** Testa se `bits` inclui todas as permissões em `flags`. */
+declare function hasPermissions(bits: bigint | PermissionBits, ...flags: bigint[]): boolean;
+/** Testa se `bits` inclui pelo menos uma das permissões em `flags`. */
+declare function hasAnyPermission(bits: bigint | PermissionBits, ...flags: bigint[]): boolean;
+/**
+ * Resolve as permissões efetivas de um membro em um canal, seguindo o
+ * algoritmo oficial: base do @everyone + OR dos cargos; `ADMINISTRATOR`
+ * encerra a conta; overwrites (@everyone → cargos → membro); sem
+ * `VIEW_CHANNEL`, o resultado é zero.
+ *
+ * O backend continua sendo a autoridade final: o resultado local é uma
+ * conveniência para evitar chamadas, não uma garantia.
+ */
+declare function resolveChannelPermissions(options: {
+    /** Permissões do cargo @everyone (o id do cargo é o próprio id do Space). */
+    everyonePermissions: bigint;
+    /** Permissões dos cargos do membro (sem contar @everyone). */
+    rolePermissions: bigint[];
+    /** Overwrites do canal (e da categoria, se houver, aplicados antes). */
+    overwrites: APIChannelOverwrite[];
+    /** Id do membro. */
+    memberId: Snowflake;
+    /** Id do cargo @everyone (o mesmo id do Space). */
+    everyoneRoleId: Snowflake;
+    /** Ids dos cargos do membro, sem contar @everyone. */
+    memberRoleIds: Snowflake[];
+}): bigint;
+/**
+ * Escopo mínimo usual para um bot que lê e responde em canais.
+ * Útil para gerar o valor do link de instalação.
+ */
+declare const SUGGESTED_TEXT_BOT_PERMISSIONS: bigint;
+/** Escopo de moderação usual (exige confirmação na instalação). */
+declare const SUGGESTED_MODERATION_PERMISSIONS: bigint;
+
+/**
+ * Cache em memória opcional: TTL por item, limite de itens e invalidação.
+ *
+ * O padrão do SDK é armazenar apenas o necessário, com acesso sob demanda
+ * aos demais dados. O cache **nunca** substitui a API: um item pode estar
+ * defasado, e o backend continua sendo a autoridade.
+ */
+interface CacheOptions {
+    /** Tempo de vida por item, em milissegundos. Padrão: 300000 (5 min). */
+    ttlMs?: number;
+    /** Máximo de itens guardados; os mais antigos são descartados. Padrão: 1000. */
+    maxSize?: number;
+    /** Função de agora, injetável para testes. */
+    now?: () => number;
+}
+declare class Cache<K, V> {
+    private readonly store;
+    private readonly ttlMs;
+    private readonly maxSize;
+    private readonly now;
+    constructor(options?: CacheOptions);
+    get(key: K): V | undefined;
+    set(key: K, value: V, ttlMs?: number): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    /** Itera itens vivos. */
+    entries(): IterableIterator<[K, V]>;
+    private peek;
+    private evictIfNeeded;
+    private sweep;
+}
+
+/**
+ * `SquordClient`: o ponto central do SDK.
+ *
+ * Valida o token contra a API (`GET /bots/@me`), conecta ao gateway, entrega
+ * eventos tipados e expõe os managers REST. O ciclo de vida completo —
+ * reconexão, heartbeat, resume e deduplicação — fica a cargo do SDK.
+ */
+
+interface ClientOptions {
+    /** Token do bot (`sqb_<id>.<segredo>`), de preferência vindo do ambiente. */
+    token: string;
+    /** URL base da API REST. Padrão: `https://api.squord.com.br/api/v1`. */
+    apiBaseURL?: string;
+    /** URL do gateway. Padrão: `wss://gateway.squord.com.br/gateway`. */
+    gatewayURL?: string;
+    /** Timeout por requisição REST, em ms. Padrão: 15000. */
+    restTimeoutMs?: number;
+    /** Base do backoff de reconexão do gateway, em ms. Padrão: 1000. */
+    gatewayReconnectBaseMs?: number;
+    /** Retentativas REST para falhas transitórias. Padrão: 3. */
+    restMaxRetries?: number;
+    /** Teto global de requisições/segundo (o oficial é 50). Padrão: 45. */
+    restGlobalPerSecond?: number;
+    /** Implementação de fetch para testes. Padrão: `fetch` global. */
+    fetchImpl?: typeof fetch;
+    /** Fábrica de WebSocket para testes. Padrão: `WebSocket` global (Node 22+). */
+    ws?: WebSocketFactory;
+    /**
+     * `true` para usar apenas o cliente REST (tarefas agendadas, CI), sem
+     * gateway. Use `login()` normalmente; ele só valida o token.
+     */
+    restOnly?: boolean;
+    /** `true` para encerrar com SIGINT/SIGTERM automaticamente. Padrão: `false`. */
+    gracefulShutdown?: boolean;
+    /** Logger do SDK (`debug`, `info`, `warn`, `error`); `null` silencia. */
+    logger?: Logger | null;
+    /** Nível do logger automático (ignorado se `logger` for informado). */
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * Cache em memória opcional (TTL e limite configuráveis). Desativado por
+     * padrão: o cliente busca os dados sob demanda.
+     */
+    cache?: {
+        enabled: boolean;
+        /** TTL por item, em ms. Padrão: 300000 (5 min). */
+        ttlMs?: number;
+        /** Máximo de itens por cache. Padrão: 500. */
+        maxEntries?: number;
+    };
+}
+declare class SquordClient extends TypedEmitter<ClientEvents> {
+    readonly rest: RestClient;
+    readonly messages: MessagesManager;
+    readonly channels: ChannelsManager;
+    readonly guilds: GuildsManager;
+    readonly members: MembersManager;
+    readonly roles: RolesManager;
+    readonly moderation: ModerationManager;
+    readonly uploads: UploadsManager;
+    readonly interactions: InteractionsManager;
+    readonly commands: ApplicationCommandsManager;
+    readonly bot: BotManager;
+    readonly users: UsersManager;
+    readonly logger: Logger;
+    /** Caches opcionais, desativados por padrão (`cache.enabled`). */
+    readonly caches: {
+        guilds: Cache<Snowflake, APIGuild>;
+        channels: Cache<Snowflake, APIChannel>;
+        members: Cache<string, APIMember>;
+        roles: Cache<Snowflake, APIRole[]>;
+    } | null;
+    private readonly options;
+    private gatewayInstance;
+    private botInfo;
+    private userIdValue;
+    private shutdownSignalsBound;
+    private destroyed;
+    constructor(options: ClientOptions);
+    /** Opções com que o cliente foi criado (sem o token). */
+    get optionsSafe(): Omit<ClientOptions, "token">;
+    /** Id da conta do bot (disponível após `login()`). */
+    get userId(): Snowflake | null;
+    /** A conta do bot como `User` (após `login()`). */
+    get user(): User | null;
+    /** O bot na visão do dono (após `login()`). */
+    get application(): APIBot | null;
+    /** O gateway, se conectado (ou em conexão). */
+    get gateway(): Gateway | null;
+    /** `true` quando o gateway está autenticado e recebendo eventos. */
+    isReady(): boolean;
+    /** Latência do gateway (último heartbeat → ack), em ms. */
+    get ping(): number | null;
+    /**
+     * Autentica e conecta. Valida o token (`GET /bots/@me`), conecta ao
+     * gateway (a menos que `restOnly`) e resolve no `ready`.
+     */
+    login(): Promise<void>;
+    /**
+     * Encerra o cliente: fecha o gateway, cancela requisições pendentes e
+     * remove listeners. Seguro chamar mais de uma vez.
+     */
+    destroy(): Promise<void>;
+    /** Presença do bot: `ONLINE`, `IDLE`, `DND` ou `INVISIBLE`, com status personalizado. */
+    setPresence(presence: {
+        status?: PresenceStatus;
+        customStatus?: string | null;
+        afk?: boolean;
+    }): void;
+    /** Força reconexão do gateway (tenta `resume`). */
+    reconnect(): void;
+    /**
+     * Permissões efetivas do bot em um canal, resolvidas localmente a partir
+     * dos cargos e overwrites (com o cache, quando habilitado). O backend
+     * continua sendo a autoridade final.
+     */
+    myPermissionsIn(channelId: Snowflake): Promise<bigint>;
+    /** Testa se o bot tem um conjunto de permissões em um canal. */
+    hasPermissionsIn(channelId: Snowflake, ...flags: bigint[]): Promise<boolean>;
+    /** Atalho para `Permissions` (evita import extra em código de bot). */
+    get Permissions(): typeof Permissions;
+    private ensureGateway;
+    private dispatchGatewayEvent;
+}
+
+/**
+ * Registro de comandos: texto (com prefixo), slash (comandos de aplicação)
+ * e componentes (botões e menus).
+ *
+ * - **Texto**: o SDK ouve `message.created`, faz o parse do prefixo e dos
+ *   argumentos e chama o handler. Suporta aliases, cooldowns e middleware.
+ * - **Slash**: handlers para `interaction.created` de comandos. O registro
+ *   pode sincronizar as definições com o Squord (`PUT` em bloco) na partida
+ *   do bot — registrar é sobrescrever, então a lista deve ser a mesma sempre.
+ * - **Componentes**: handlers para cliques em botões e escolhas em menus,
+ *   identificados pelo `customId` (aceito prefixo com `*` no final).
+ */
+
+interface TextCommandDefinition {
+    /** Nome principal (sem o prefixo). Letras minúsculas recomendadas. */
+    name: string;
+    /** Nomes alternativos. */
+    aliases?: string[];
+    /** Descrição usada em mensagens de erro e ajuda. */
+    description?: string;
+    /** Deixa o comando oculto em listagens de ajuda. */
+    hidden?: boolean;
+    /** Cooldown por usuário, em ms. Padrão: sem cooldown. */
+    cooldownMs?: number;
+    /** Caso a mensagem deve ignorar bots (padrão `true`). */
+    ignoreBots?: boolean;
+    /** Onde o comando vale: em qualquer Space ou em Spaces específicos. */
+    guildIds?: Snowflake[];
+    /** Middleware antes da execução; devolve `false` para abortar. */
+    beforeExecute?: (context: TextCommandContext) => boolean | Promise<boolean>;
+    execute: (context: TextCommandContext) => unknown | Promise<unknown>;
+}
+interface TextCommandContext {
+    /** O cliente do bot. */
+    client: SquordClient;
+    /** A mensagem que invocou o comando. */
+    message: Message;
+    /** Nome invocado (pode ser um alias). */
+    name: string;
+    /** Definição do comando. */
+    command: TextCommandDefinition;
+    /** Argumentos crus, já com aspas tratadas. */
+    args: string[];
+    /** A linha de argumentos como veio (sem o nome do comando). */
+    rawArgs: string;
+    /** Responde no canal (sem citar). */
+    reply(payload: string | Parameters<Message["reply"]>[0]): ReturnType<Message["reply"]>;
+    /** Responde citando a mensagem original. */
+    replyWithMention(payload: string | Parameters<Message["reply"]>[0]): ReturnType<Message["reply"]>;
+    /** Reage à mensagem que invocou. */
+    react(emoji: string): Promise<void>;
+}
+interface SlashCommandDefinition {
+    /** Letras minúsculas, números, `_` e `-` (até 32 caracteres). */
+    name: string;
+    /** Até 100 caracteres. */
+    description: string;
+    /** Até 25 opções; as obrigatórias vêm antes das opcionais. */
+    options?: APICommandOptionInput[];
+    /** Onde publicar: `"global"` (padrão) ou Spaces específicos. */
+    scope?: {
+        kind: "global";
+    } | {
+        kind: "guild";
+        guildIds: Snowflake[];
+    };
+    execute: (interaction: Interaction) => unknown | Promise<unknown>;
+}
+interface ComponentHandlerDefinition {
+    /** `customId` do componente. Terminando em `*`, casa por prefixo. */
+    customId: string;
+    execute: (interaction: Interaction) => unknown | Promise<unknown>;
+}
+interface CommandRegistryOptions {
+    /** Prefixo dos comandos de texto: string ou função (padrão `"!"`). */
+    prefix?: string | ((message: Message) => string | null);
+    /**
+     * Sincronizar os slash commands com o Squord no login (PUT em bloco,
+     * sobrescrevendo o que existir). Padrão: `true` quando houver comandos.
+     */
+    syncOnLogin?: boolean;
+    /** Se `true`, ignora mensagens de bots nos comandos de texto (padrão). */
+    ignoreBots?: boolean;
+    /** Handler para erros dos comandos (texto e slash). */
+    onError?: (error: unknown, context: {
+        command?: string;
+        message?: Message;
+        interaction?: Interaction;
+    }) => void;
+}
+declare class CommandRegistry {
+    private readonly client;
+    private readonly options;
+    private readonly textCommands;
+    private readonly slashCommands;
+    private readonly componentHandlers;
+    private readonly cooldowns;
+    private readonly prefixResolver;
+    private attached;
+    constructor(client: SquordClient, options?: CommandRegistryOptions);
+    /** Registra um comando de texto. */
+    text(definition: TextCommandDefinition): this;
+    /** Registra um comando slash. */
+    slash(definition: SlashCommandDefinition): this;
+    /** Registra um handler de componente (botão ou menu). */
+    component(definition: ComponentHandlerDefinition): this;
+    /** Remove um handler de componente. */
+    removeComponent(customId: string): this;
+    /** Definições slash prontas para o `PUT` em bloco. */
+    toCommandsInput(): APICommandInput[];
+    /**
+     * Sincroniza os slash commands com o Squord (PUT em bloco, sobrescrevendo
+     * o que existir em cada escopo). Chame após `client.login()` — ou deixe o
+     * registro fazer automaticamente no `ready` (`syncOnLogin`, o padrão).
+     */
+    sync(): Promise<void>;
+    /** Limpa os cooldowns (útil em testes). */
+    clearCooldowns(): void;
+    /** Processa manualmente uma mensagem como possível comando de texto (para testes). */
+    handleTextMessage(message: Message): Promise<boolean>;
+    /** Processa manualmente uma interação (para testes). */
+    handleInteraction(interaction: Interaction): Promise<boolean>;
+    private matchComponent;
+    private resolvePrefix;
+    private ensureAttached;
+    private reportError;
+}
+
+/**
+ * Iteração sobre listas paginadas por cursor.
+ *
+ * A API devolve `{ items, prevCursor, nextCursor, hasMore }`. Este helper
+ * converte uma função de página em um `AsyncGenerator` de itens, para
+ * processar o histórico sem carregar tudo em memória.
+ */
+
+type PageFetcher<T> = (params: CursorPaginationParams) => Promise<Page<T>>;
+/**
+ * Percorre as páginas de uma lista, emitindo os itens um a um.
+ *
+ * @param fetchPage função que busca uma página (`limit`, `before`, `after`).
+ * @param firstParams parâmetros da primeira página.
+ * @param direction percorre para trás (`before`, o padrão do histórico)
+ *   ou para frente (`after`).
+ */
+declare function paginate<T>(fetchPage: PageFetcher<T>, firstParams?: CursorPaginationParams, direction?: "before" | "after"): AsyncGenerator<T, void, unknown>;
+/** Coleta todos os itens de uma paginação em um array (use com critério). */
+declare function collectPagination<T>(fetchPage: PageFetcher<T>, firstParams?: CursorPaginationParams, direction?: "before" | "after", maxItems?: number): Promise<T[]>;
+
+/**
+ * Hierarquia de erros do SDK.
+ *
+ * A API devolve um envelope único (`statusCode`, `code`, `message`, `details`,
+ * `requestId`). Decida pelo `code`, nunca pela `message`. Cada erro do SDK
+ * expõe propriedades consistentes: `code`, `status`, `requestId`,
+ * `retryAfter` e `cause`, quando aplicáveis.
+ *
+ * @see https://docs.squord.com.br/referencia/erros
+ */
+
+/** Base de todos os erros lançados pelo SDK. */
+declare class SquordError extends Error {
+    /** Código estável do erro, em `SCREAMING_SNAKE`. */
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Erro devolvido pela API REST do Squord. Teste sempre pelo `code`
+ * (ex.: `err.code === "MISSING_PERMISSION"`), nunca pela `message`.
+ */
+declare class SquordAPIError extends SquordError {
+    /** Status HTTP da resposta. */
+    readonly status: number;
+    /** O mesmo valor do header `x-request-id` da resposta. */
+    readonly requestId: string | null;
+    /** Corpo bruto do erro (o envelope completo), quando disponível. */
+    readonly responseBody: APIErrorBody | null;
+    /** `details` do envelope, quando existe. */
+    readonly details: unknown;
+    constructor(body: APIErrorBody, status: number, requestId?: string | null);
+}
+/** `401 UNAUTHENTICATED` — não há credencial na requisição. */
+declare class AuthenticationError extends SquordAPIError {
+}
+/** `401 INVALID_TOKEN` — token malformado, revogado ou trocado, ou bot/dono excluído ou suspenso. */
+declare class InvalidTokenError extends AuthenticationError {
+}
+/** `403` — a credencial é válida, mas a ação não é permitida (`MISSING_PERMISSION`, `FORBIDDEN`, `NOT_A_MEMBER`, ...). */
+declare class PermissionError extends SquordAPIError {
+    /** Nome da permissão que faltou, quando o erro é `MISSING_PERMISSION`. */
+    readonly missingPermission: string | null;
+    constructor(body: APIErrorBody, status: number, requestId?: string | null);
+}
+/** `404` — recurso inexistente ou invisível para o bot. */
+declare class NotFoundError extends SquordAPIError {
+}
+/** `422 VALIDATION_FAILED` — corpo bem formado, mas inválido. */
+declare class ValidationError extends SquordAPIError {
+    /** Os itens de validação (campo, código do item, limite violado). */
+    readonly issues: APIValidationIssue[];
+    constructor(body: APIErrorBody, status: number, requestId?: string | null);
+}
+/** `429 RATE_LIMITED` — limite de taxa. Espere `retryAfter` segundos. */
+declare class RateLimitError extends SquordAPIError {
+    /** Segundos de espera informados pelo servidor (mínimo 1). */
+    readonly retryAfter: number;
+    /** O bucket que recusou (`MESSAGE_CREATE`, `BOT_GLOBAL`, ...). */
+    readonly bucket: string | null;
+    /** `true` quando o SDK já esgotou as retentativas automáticas. */
+    readonly exhaustedRetries: boolean;
+    constructor(body: APIErrorBody, status: number, options?: {
+        requestId?: string | null;
+        exhaustedRetries?: boolean;
+    });
+}
+/** Falha de rede antes de receber qualquer resposta (DNS, TCP, TLS). */
+declare class NetworkError extends SquordError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** A requisição excedeu o tempo limite configurado. */
+declare class RequestTimeoutError extends SquordError {
+    /** Milissegundos configurados de timeout. */
+    readonly timeoutMs: number;
+    /** Método HTTP da requisição que expirou. */
+    readonly method: string;
+    /** Caminho da requisição que expirou. */
+    readonly path: string;
+    constructor(method: string, path: string, timeoutMs: number, options?: {
+        cause?: unknown;
+    });
+}
+/** Erro de conexão/fechamento do gateway. */
+declare class GatewayError extends SquordError {
+    /** Código de fechamento (4000+) ou `null` em falhas de rede. */
+    readonly closeCode: number | null;
+    /** Razão textual enviada pelo servidor (informativa; use `closeCode`). */
+    readonly reason: string | null;
+    constructor(closeCode: number | null, reason: string | null, message?: string);
+}
+/** Erro de uso incorreto da API do SDK (argumentos inválidos no cliente). */
+declare class SquordTypeError extends SquordError {
+    constructor(message: string);
+}
+/**
+ * Normaliza um corpo de erro em {@link SquordAPIError} ou uma subclasse.
+ * Exportado para testes e uso avançado.
+ */
+declare function makeAPIError(body: APIErrorBody, status: number, requestId?: string | null): SquordAPIError;
+
+/**
+ * Intents do gateway.
+ *
+ * As intents são configuradas por bot (Configurações → Desenvolvedor, ou
+ * `PATCH /bots/{bot.id}`) e **não** vão no `identify`: o gateway lê as
+ * intents do bot no momento do identify. Este módulo serve para calcular,
+ * exibir e comparar valores — por exemplo, ao gerenciar o bot pela API.
+ *
+ * O padrão de um bot novo é `GUILDS | GUILD_MESSAGES | GUILD_MESSAGE_REACTIONS`
+ * (valor `13`).
+ *
+ * @see https://docs.squord.com.br/gateway/intents
+ */
+declare const Intents: {
+    /** Space, canais, cargos, threads, emojis, stickers, eventos do Space. */
+    readonly GUILDS: number;
+    /** Entrada, saída, edição e ban de membros. */
+    readonly GUILD_MEMBERS: number;
+    /** `message.*` e votos de enquete. */
+    readonly GUILD_MESSAGES: number;
+    /** Reações. */
+    readonly GUILD_MESSAGE_REACTIONS: number;
+    /** Estado e salas de voz. */
+    readonly GUILD_VOICE_STATES: number;
+    /**
+     * **Privilegiada.** Não liga evento nenhum: devolve o conteúdo das
+     * mensagens. Sem ela, `content`, `embeds`, `attachments`, `components`
+     * e `poll` chegam esvaziados — exceto mensagens do próprio bot e as que
+     * o mencionam.
+     */
+    readonly MESSAGE_CONTENT: number;
+};
+type IntentFlag = keyof typeof Intents;
+/** Intents padrão de um bot novo. */
+declare const DEFAULT_INTENTS: number;
+/** Soma flags de intent em um número (0 a 65535). */
+declare function intentsValue(...flags: number[]): number;
+/** Lista as flags conhecidas presentes em um valor de intents. */
+declare function listIntents(value: number): IntentFlag[];
+
+/**
+ * Backoff exponencial com jitter, para reconexões do gateway e retentativas
+ * de REST. A recomendação da documentação: 1 s, 2 s, 4 s ... até 60 s, mais
+ * um valor aleatório.
+ */
+interface BackoffOptions {
+    /** Primeira espera, em milissegundos. Padrão 1000. */
+    baseMs?: number;
+    /** Multiplicador entre tentativas. Padrão 2. */
+    factor?: number;
+    /** Teto da espera base, em milissegundos. Padrão 60000. */
+    maxMs?: number;
+    /** Fração de jitter: 0.25 espera ±25%. Padrão 0.25. */
+    jitter?: number;
+}
+/** Calcula a espera para a tentativa `attempt` (0-based). */
+declare function backoffDelay(attempt: number, options?: BackoffOptions): number;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+
+/** Divide argumentos de uma linha de comando, respeitando aspas. */
+declare function splitArguments(input: string): string[];
+
+/**
+ * Validação e manipulação de ids do Squord.
+ *
+ * Ids são strings opacas: Snowflakes decimais de até 20 dígitos, ou o formato
+ * antigo de 24 caracteres hexadecimais. Nunca converta para `number`.
+ */
+/** Verifica se um valor parece um id válido do Squord. */
+declare function isValidSnowflake(id: string): boolean;
+/** Lança `SquordTypeError` se o id não tiver o formato de id do Squord. */
+declare function assertSnowflake(id: string, label?: string): string;
+/** Compara dois ids por ordem numérica (seguro com ids grandes, via BigInt). */
+declare function compareSnowflakes(a: string, b: string): number;
+
+export { ALL_PERMISSIONS, APIBot, APIChannel, APIChannelOverwrite, APIChannelTreeNode, APICommand, APICommandInput, APICommandOptionInput, APIComponentRow, APIEmbed, APIEmbedInput, APIForumPostCreateBody, APIGuild, APIInteraction, APIInteractionCallbackBody, APIInteractionCommandData, APIInteractionComponentData, APIInteractionReplyData, APIMember, APIMemberBan, APIMemberBanBody, APIMemberEditBody, APIMemberPage, APIMessage, APIMessageCreateBody, APIMessagePage, APIReaction, APIRole, APISelectMenu, APISelectOption, APIThread, APIThreadCreateBody, APIThreadListParams, APIThreadPage, APIUpload, APIUploadReservation, APIUser, ActionRowBuilder, AllowedMentions, ApplicationCommandsManager, AuthenticationError, BotManager, ButtonBuilder, ButtonStyle, Buttons, Cache, type CacheOptions, Channel, type ChannelTreeGroup, ChannelType, ChannelsManager, type ClientEvents, type ClientOpcode, type ClientOptions, CommandOptionType, CommandRegistry, type CommandRegistryOptions, type ComponentHandlerDefinition, ComponentLimits, CursorPaginationParams, DEFAULT_INTENTS, EmbedBuilder, EmbedLimits, Gateway, type GatewayCloseCode, GatewayCloseCodes, GatewayError, type GatewayEventName, type GatewayEvents, type GatewayOptions, type GatewayStatus, Guild, GuildsManager, type HttpMethod, ISODate, type IntentFlag, Intents, Interaction, InteractionsManager, InvalidTokenError, type LogLevel, type Logger, Member, type MemberListParams, MembersManager, Message, type MessagePayload, MessageType, MessagesManager, ModerationManager, NetworkError, NotFoundError, Page, type PageFetcher, PermissionBits, PermissionError, type PermissionFlag, Permissions, type PresenceStatus, RateLimitError, type ReadyEvent, type RequestOptions, RequestTimeoutError, RestClient, type RestClientOptions, type RestResponse, Role, RolesManager, SUGGESTED_MODERATION_PERMISSIONS, SUGGESTED_TEXT_BOT_PERMISSIONS, SelectMenuBuilder, type SendOptions, type ServerFrame, type ServerOpcode, type SlashCommandDefinition, Snowflake, SquordAPIError, SquordClient, SquordError, SquordTypeError, type TextCommandContext, type TextCommandDefinition, Thread, type UploadOptions, type UploadSource, UploadsManager, User, UsersManager, ValidationError, type WebSocketFactory, type WebSocketLike, assertSnowflake, attachWebSocket, backoffDelay, collectPagination, compareSnowflakes, createConsoleLogger, hasAnyPermission, hasPermissions, intentsValue, isValidSnowflake, listIntents, loggerFromEnv, makeAPIError, noopLogger, normalizeEmbedColor, paginate, parsePermissions, permissionsToString, redact, resolveChannelPermissions, resolveMessagePayload, routeKeyOf, sleep, splitArguments };