lunibee 0.2.3 → 0.3.0

package/dist/core/commands.d.ts

@@ -0,0 +1,232 @@
+import type { InteractionReplyOptions } from "@lunibee/structures";
+import type { CommandInteraction, GuildMember, Message } from "@lunibee/structures";
+import { type APIAttachment, type ChannelKind } from "@lunibee/types";
+import { type PermissionName } from "./permissions.js";
+import type { Client } from "./index.js";
+/** What every option takes. */
+interface OptionConfig {
+    /** Shown in Discord's command picker (1-100 characters). Defaults to the option's name. */
+    description?: string;
+    /** Whether the command cannot run without it. */
+    required?: boolean;
+}
+/** A string option. */
+export interface StringConfig extends OptionConfig {
+    default?: string;
+    /** Shortest and longest accepted text. */
+    min?: number;
+    max?: number;
+    /** Allowed values, as plain text or `{ name, value }` pairs. */
+    choices?: readonly (string | {
+        name: string;
+        value: string;
+    })[];
+}
+/** An integer or number option. */
+export interface NumberConfig extends OptionConfig {
+    default?: number;
+    /** Smallest and largest accepted value. */
+    min?: number;
+    max?: number;
+    choices?: readonly (number | {
+        name: string;
+        value: number;
+    })[];
+}
+/** A true/false option. */
+export interface BooleanConfig extends OptionConfig {
+    default?: boolean;
+}
+/** A channel option. */
+export interface ChannelConfig extends OptionConfig {
+    /** Only these kinds of channel are accepted (all by default). */
+    kinds?: readonly ChannelKind[];
+}
+/** A choice between fixed words. */
+export interface ChoiceConfig<V extends string> extends OptionConfig {
+    default?: V;
+}
+/** Which option kind a definition is. */
+type OptionKind = "string" | "integer" | "number" | "boolean" | "user" | "channel" | "role" | "mentionable" | "attachment";
+/** A mention or id that can be either a user or a role. */
+export interface MentionableValue {
+    id: string;
+    type: "user" | "role";
+}
+/**
+ * One option of a command. `T` is the type the handler receives and `C` the
+ * configuration it was made with, which decides whether it can be missing.
+ * Make one with {@link option}.
+ */
+export interface OptionDef<T, C> {
+    readonly kind: OptionKind;
+    readonly config: C;
+    /** Choices for {@link option.choice}; undefined for the other kinds. */
+    readonly words?: readonly string[];
+    /** Type only: the type the handler receives. Never present at runtime. */
+    readonly __type: T;
+}
+type AnyOption = OptionDef<unknown, object>;
+/** The options of a command, by name. */
+export type OptionMap = Record<string, AnyOption>;
+/**
+ * Describes the options of a command. The key you give each one in
+ * `command({ options })` is its name; the handler gets them typed.
+ *
+ * - An option is required when `required: true`, and also never missing when it has a `default`.
+ * - `user`, `role` and `channel` give the id; `mentionable` gives `{ id, type }`;
+ *   `attachment` gives the attachment.
+ */
+export declare const option: {
+    string: <const C extends StringConfig>(config?: C) => OptionDef<string, C>;
+    integer: <const C extends NumberConfig>(config?: C) => OptionDef<number, C>;
+    number: <const C extends NumberConfig>(config?: C) => OptionDef<number, C>;
+    boolean: <const C extends BooleanConfig>(config?: C) => OptionDef<boolean, C>;
+    user: <const C extends OptionConfig>(config?: C) => OptionDef<string, C>;
+    role: <const C extends OptionConfig>(config?: C) => OptionDef<string, C>;
+    channel: <const C extends ChannelConfig>(config?: C) => OptionDef<string, C>;
+    mentionable: <const C extends OptionConfig>(config?: C) => OptionDef<MentionableValue, C>;
+    attachment: <const C extends OptionConfig>(config?: C) => OptionDef<APIAttachment, C>;
+    /** A choice between fixed words; the handler gets the word, typed as the union. */
+    choice: <const W extends readonly string[], const C extends ChoiceConfig<W[number]>>(words: W, config?: C) => OptionDef<W[number], C>;
+};
+type IsNeeded<C> = C extends {
+    required: true;
+} ? true : C extends {
+    default: string | number | boolean;
+} ? true : false;
+type ValueOf<D> = D extends OptionDef<infer T, unknown> ? T : never;
+type ConfigOf<D> = D extends OptionDef<unknown, infer C> ? C : never;
+type RequiredKeys<M extends OptionMap> = {
+    [K in keyof M]: IsNeeded<ConfigOf<M[K]>> extends true ? K : never;
+}[keyof M];
+/** The values a handler receives: required (or defaulted) options always, the rest possibly missing. */
+export type OptionValues<M extends OptionMap> = {
+    [K in RequiredKeys<M>]: ValueOf<M[K]>;
+} & {
+    [K in Exclude<keyof M, RequiredKeys<M>>]?: ValueOf<M[K]>;
+};
+/** What a command handler gets, whether it was run as `/name` or as `!name`. */
+export interface CommandContext<M extends OptionMap = OptionMap> {
+    bot: Client;
+    /** The command's options, typed from its definition. */
+    options: OptionValues<M>;
+    /** How it was run. */
+    source: "slash" | "prefix";
+    guildId: string | undefined;
+    channelId: string | undefined;
+    /** The id of whoever ran it. */
+    userId: string;
+    /** The person who ran it as a guild member, when it ran in a guild. */
+    member: GuildMember | null;
+    /** The slash interaction, when `source` is `"slash"`. */
+    interaction: CommandInteraction | undefined;
+    /** The message, when `source` is `"prefix"`. */
+    message: Message | undefined;
+    /**
+     * Answers the command: an interaction reply for a slash command (a first
+     * reply, an edit after `defer()`, then follow-ups), a message reply for a
+     * prefix command. `ephemeral` only means something for slash commands.
+     */
+    reply(content: string | InteractionReplyOptions): Promise<void>;
+    /** Tells Discord the answer will take a while (slash commands only; a no-op for prefix commands). */
+    defer(options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+}
+/** The definition `command()` takes. */
+export interface CommandDefinition<M extends OptionMap> {
+    /** 1-32 lowercase letters, digits, `-` or `_`. */
+    name: string;
+    /** 1-100 characters. */
+    description: string;
+    options?: M;
+    /** Permissions the person needs; checked by Discord for slash commands and by Lunibee for prefix commands. Implies `guildOnly`. */
+    permissions?: readonly PermissionName[];
+    /** Only allow it in servers. */
+    guildOnly?: boolean;
+    nsfw?: boolean;
+    /** Answer `!name args` too, with the same options; `{ aliases }` adds other names. */
+    prefix?: boolean | {
+        aliases?: readonly string[];
+    };
+    /** Register it as a slash command (default `true`); `false` makes a prefix-only command. */
+    slash?: boolean;
+    run(context: CommandContext<M>): unknown;
+}
+/** A command made by {@link command}. */
+export interface Command<M extends OptionMap = OptionMap> {
+    readonly name: string;
+    readonly description: string;
+    readonly options: M;
+    readonly permissions: readonly PermissionName[];
+    readonly guildOnly: boolean;
+    readonly nsfw: boolean;
+    /** Whether it is registered as a slash command. */
+    readonly slash: boolean;
+    /** Whether it answers a prefix, and under which other names. */
+    readonly prefix: false | {
+        aliases: readonly string[];
+    };
+    run(context: CommandContext<M>): unknown;
+    /** The slash command as Discord expects it. */
+    toJSON(): Record<string, unknown>;
+    /** The usage line of the prefix form, such as `!timeout <user> [minutes] [reason…]`. */
+    usage(prefix: string): string;
+}
+/**
+ * Defines a command once; it can be a slash command, a prefix command, or both.
+ * @example
+ * export default command({
+ *   name: "timeout",
+ *   description: "Time a member out",
+ *   permissions: ["ModerateMembers"],
+ *   options: {
+ *     user: option.user({ required: true }),
+ *     minutes: option.integer({ min: 1, max: 40_320, default: 10 }),
+ *     reason: option.string({ max: 500 }),
+ *   },
+ *   prefix: true,
+ *   async run({ bot, options, guildId, reply }) {
+ *     await bot.member(guildId!, options.user).timeout(`${options.minutes}m`, options.reason);
+ *     await reply(`Timed out <@${options.user}>.`);
+ *   },
+ * });
+ * @throws {RangeError} For a name, description or option Discord would refuse.
+ * @throws {TypeError} If it is neither a slash nor a prefix command, or a required option follows an optional one.
+ */
+export declare function command<const M extends OptionMap = Record<never, never>>(definition: CommandDefinition<M>): Command<M>;
+/** Adds slash and prefix commands and runs them. Reached as `bot.commands`. */
+export declare class CommandRegistry {
+    #private;
+    constructor(bot: Client);
+    /**
+     * Adds commands, replacing one with the same name.
+     * @throws {TypeError} If a prefix name or alias is already taken by another command.
+     */
+    add(...commands: Command<OptionMap>[]): this;
+    /** The command named `name` (or one of its prefix aliases). */
+    get(name: string): Command<OptionMap> | undefined;
+    /** Every command, in the order they were added. */
+    list(): Command<OptionMap>[];
+    /**
+     * Registers the slash commands with Discord, replacing the ones already
+     * registered. Call it once the client is ready.
+     * @param options `guildId` registers them in one guild (instant) instead of globally.
+     * @returns How many were registered.
+     * @throws {Error} If the client is not ready.
+     */
+    deploy(options?: {
+        guildId?: string;
+    }): Promise<number>;
+    /**
+     * Starts answering: slash commands from interactions and, when `prefix`
+     * is given, prefix commands from messages.
+     * @param options.prefix The text a message starts with, or several.
+     * @throws {TypeError} If called twice.
+     */
+    listen(options?: {
+        prefix?: string | readonly string[];
+    }): this;
+}
+export {};

package/dist/core/events.d.ts

@@ -94,8 +94,8 @@ export type ClientEvents = {
         action: string;
     }];
     messageCreate: [message: Message];
-    /** `previous` is the cached version, available when `messageCache` is enabled. */
-    messageUpdate: [message: Message, previous?: Message];
+    /** `previous` is the cached version, or `null` unless `messageCache` is enabled and the message was cached. */
+    messageUpdate: [message: Message, previous: Message | null];
     /** `message` is the cached message, available when `messageCache` is enabled. */
     messageDelete: [data: APIMessageDeleteEvent, message?: Message];
     /** `messages` are the cached messages that were deleted (empty without `messageCache`). */
@@ -161,12 +161,20 @@ export type ClientEvents = {
         guild_id: string;
     }];
     guildScheduledEventCreate: [data: APIGuildScheduledEvent];
-    guildScheduledEventUpdate: [data: APIGuildScheduledEvent];
+    /** `previous` is the cached event, or `null` if it was not cached. */
+    guildScheduledEventUpdate: [
+        data: APIGuildScheduledEvent,
+        previous: APIGuildScheduledEvent | null
+    ];
     guildScheduledEventDelete: [data: APIGuildScheduledEvent];
     guildScheduledEventUserAdd: [data: APIGuildScheduledEventUserEvent];
     guildScheduledEventUserRemove: [data: APIGuildScheduledEventUserEvent];
     autoModerationRuleCreate: [data: APIAutoModerationRule];
-    autoModerationRuleUpdate: [data: APIAutoModerationRule];
+    /** `previous` is the cached rule, or `null` if it was not cached. */
+    autoModerationRuleUpdate: [
+        data: APIAutoModerationRule,
+        previous: APIAutoModerationRule | null
+    ];
     autoModerationRuleDelete: [data: APIAutoModerationRule];
     autoModerationActionExecution: [data: APIAutoModerationActionExecution];
     channelCreate: [channel: Channel];
@@ -184,14 +192,23 @@ export type ClientEvents = {
     threadMembersUpdate: [data: APIThreadMembersUpdate];
     threadMemberUpdate: [data: APIThreadMember];
     stageInstanceCreate: [data: APIStageInstance];
-    stageInstanceUpdate: [data: APIStageInstance];
+    /** `previous` is the cached stage instance, or `null` if it was not cached. */
+    stageInstanceUpdate: [
+        data: APIStageInstance,
+        previous: APIStageInstance | null
+    ];
     stageInstanceDelete: [data: APIStageInstance];
     inviteCreate: [data: APIInviteCreate];
     inviteDelete: [data: APIInviteDelete];
     webhooksUpdate: [data: APIWebhooksUpdate];
-    voiceStateUpdate: [data: APIVoiceState];
+    /** `previous` is the user's last known voice state in that guild, or `null` (first sighting, or not in a guild). */
+    voiceStateUpdate: [data: APIVoiceState, previous: APIVoiceState | null];
     voiceServerUpdate: [data: APIVoiceServerUpdate];
-    presenceUpdate: [data: APIPresenceUpdate];
+    /** `previous` is the last presence seen, available with `cache: { presences: true }`; otherwise `null`. */
+    presenceUpdate: [
+        data: APIPresenceUpdate,
+        previous: APIPresenceUpdate | null
+    ];
     typingStart: [data: APITypingStart];
     interactionCreate: [interaction: Interaction];
 };

package/dist/core/handles.d.ts

@@ -0,0 +1,157 @@
+import type { Collection } from "@lunibee/collection";
+import type { ChannelKind, UnknownChannelKind } from "@lunibee/types";
+import type { BanOptions, ChannelEditOptions, GuildManager, MemberEditOptions, MessageCreateOptions, MessageEditOptions, MessageQueryOptions, RoleEditOptions } from "@lunibee/managers";
+import type { Channel, ChannelOfKind, Guild, GuildMember, Message, Role, User } from "@lunibee/structures";
+import type { Client } from "./index.js";
+import { type CreateChannelOptions } from "./channel-create.js";
+/** A length of time: milliseconds, or text such as `"90s"`, `"10m"`, `"2h"`, `"1d"`, `"1w"` or `"1h30m"`. */
+export type Duration = number | string;
+/**
+ * Turns a {@link Duration} into milliseconds.
+ * @throws {RangeError} If a number is negative or not finite, or the text is not a duration.
+ */
+export declare function parseDuration(value: Duration): number;
+/** Message text, or a full payload. */
+export type MessageInput = string | MessageCreateOptions;
+/**
+ * A reference to one Discord thing by its ids. A handle holds no data, so it
+ * is cheap to create, can be made before the thing is cached, and fails only
+ * when you use it.
+ *
+ * - `peek()` reads the cache and returns `undefined` when it is not there.
+ * - `get()` reads the cache, and asks Discord when it is not there.
+ * - `fetch()` asks Discord now and refreshes the cache.
+ */
+export interface Handle<T> {
+    peek(): T | undefined;
+    get(): Promise<T>;
+    fetch(): Promise<T>;
+}
+/** A user, by id. Made by `bot.person(id)`. */
+export declare class UserHandle implements Handle<User> {
+    private readonly bot;
+    readonly id: string;
+    constructor(bot: Client, id: string);
+    peek(): User | undefined;
+    get(): Promise<User>;
+    fetch(): Promise<User>;
+    /** Opens (or reuses) the direct-message channel with this user. */
+    dm(): Promise<ChannelHandle>;
+    /** Sends this user a direct message. */
+    send(message: MessageInput): Promise<Message>;
+}
+/** A guild, by id. Made by `bot.guild(id)`. */
+export declare class GuildHandle implements Handle<Guild> {
+    private readonly bot;
+    readonly id: string;
+    constructor(bot: Client, id: string);
+    peek(): Guild | undefined;
+    get(): Promise<Guild>;
+    fetch(): Promise<Guild>;
+    /** The cached members, live: it changes as the Gateway updates them. */
+    get members(): Collection<string, GuildMember>;
+    /** The cached roles, live. */
+    get roles(): Collection<string, Role>;
+    /** The cached channels of this guild, as a snapshot taken when you read it. */
+    get channels(): Collection<string, Channel>;
+    member(userId: string): MemberHandle;
+    role(roleId: string): RoleHandle;
+    channel(channelId: string): ChannelHandle;
+    /**
+     * Creates a channel. `kind` decides which other options apply, and the
+     * result is typed to match: a `"voice"` option gives a `VoiceChannel`.
+     * @example await bot.guild(id).createChannel({ kind: "text", name: "general", parent: categoryId });
+     */
+    createChannel<O extends CreateChannelOptions>(options: O): Promise<ChannelOfKind<O["kind"]>>;
+    /** Bans a user, whether or not they are a member. */
+    ban(userId: string, options?: BanOptions): Promise<void>;
+    /** Lifts a ban. */
+    unban(userId: string, reason?: string): Promise<void>;
+    /** Changes the guild's settings; `reason` is the audit-log reason. */
+    edit(options: Parameters<GuildManager["edit"]>[1]): Promise<Guild>;
+    /** Makes the bot leave the guild. */
+    leave(): Promise<void>;
+}
+/** A guild member, by guild id and user id. Made by `bot.member(guildId, userId)`. */
+export declare class MemberHandle implements Handle<GuildMember> {
+    private readonly bot;
+    readonly guildId: string;
+    readonly userId: string;
+    constructor(bot: Client, guildId: string, userId: string);
+    private get members();
+    peek(): GuildMember | undefined;
+    get(): Promise<GuildMember>;
+    fetch(): Promise<GuildMember>;
+    guild(): GuildHandle;
+    user(): UserHandle;
+    kick(reason?: string): Promise<void>;
+    ban(options?: BanOptions): Promise<void>;
+    unban(reason?: string): Promise<void>;
+    /** Changes nickname, roles, mute or deafen; put the audit-log reason in `options.reason`. */
+    edit(options: MemberEditOptions): Promise<GuildMember>;
+    addRole(roleId: string, reason?: string): Promise<void>;
+    removeRole(roleId: string, reason?: string): Promise<void>;
+    /**
+     * Times the member out for `duration` (`"10m"`, `"2h"`, 90_000), or lifts
+     * the timeout with `null`.
+     */
+    timeout(duration: Duration | null, reason?: string): Promise<GuildMember>;
+}
+/** A role, by guild id and role id. Made by `bot.role(guildId, roleId)`. */
+export declare class RoleHandle implements Handle<Role> {
+    private readonly bot;
+    readonly guildId: string;
+    readonly roleId: string;
+    constructor(bot: Client, guildId: string, roleId: string);
+    private get roles();
+    peek(): Role | undefined;
+    get(): Promise<Role>;
+    fetch(): Promise<Role>;
+    edit(options: RoleEditOptions): Promise<Role>;
+    delete(reason?: string): Promise<void>;
+}
+/** A channel, by id. Made by `bot.channel(id)`. */
+export declare class ChannelHandle implements Handle<Channel> {
+    private readonly bot;
+    readonly id: string;
+    constructor(bot: Client, id: string);
+    peek(): Channel | undefined;
+    get(): Promise<Channel>;
+    fetch(): Promise<Channel>;
+    message(messageId: string): MessageHandle;
+    /**
+     * Gets the channel (cache, else Discord) and returns it typed as one of
+     * `kinds`.
+     * @throws {TypeError} If it is a different kind.
+     */
+    as<K extends ChannelKind | UnknownChannelKind>(...kinds: K[]): Promise<ChannelOfKind<K>>;
+    /** Sends a message: text, or a full payload (`embeds`, `components`, `files`, …). */
+    send(message: MessageInput): Promise<Message>;
+    /** Reads messages: the latest, or around / before / after one. */
+    messages(query?: MessageQueryOptions): Promise<Message[]>;
+    edit(options: ChannelEditOptions): Promise<Channel>;
+    delete(reason?: string): Promise<void>;
+    /** Deletes up to 100 messages younger than 14 days. */
+    bulkDelete(messageIds: Iterable<string>, reason?: string): Promise<void>;
+}
+/** A message, by channel id and message id. Made by `bot.message(channelId, messageId)`. */
+export declare class MessageHandle implements Handle<Message> {
+    private readonly bot;
+    readonly channelId: string;
+    readonly messageId: string;
+    constructor(bot: Client, channelId: string, messageId: string);
+    peek(): Message | undefined;
+    get(): Promise<Message>;
+    fetch(): Promise<Message>;
+    channel(): ChannelHandle;
+    edit(message: string | MessageEditOptions): Promise<Message>;
+    delete(reason?: string): Promise<void>;
+    /** Sends a message that replies to this one. */
+    reply(message: MessageInput): Promise<Message>;
+    /** Adds the bot's reaction (`"👍"`, or `"name:id"` for a custom emoji). */
+    react(emoji: string): Promise<void>;
+    pin(reason?: string): Promise<void>;
+    unpin(reason?: string): Promise<void>;
+    /** Publishes the message from an announcement channel. */
+    crosspost(): Promise<Message>;
+}

package/dist/core/index.d.ts

@@ -1,10 +1,14 @@
-export { Permission, Permissions, PermissionFlagsBits, PermissionSet, PermissionsBitField, PermissionOverwriteEnum, PermissionOverwriteType, computePermissions, type PermissionContext, type PermissionOverwrite, type PermissionRole, type PermissionName, } from "./permissions.js";
+export { Permission, Permissions, PermissionFlagsBits, PermissionSet, PermissionsBitField, PermissionOverwriteEnum, computePermissions, type PermissionContext, type PermissionOverwrite, type PermissionRole, type PermissionName, } from "./permissions.js";
 export { ClientEvent, 
 /** Discord.js-familiar alias for {@link ClientEvent}. */
 ClientEvent as Events, type ClientEventName, type ClientEvents, type ClientListener, } from "./events.js";
 export { Collector, type CollectorOptions } from "./collector.js";
+export { createApi, type Api, type ApplicationNode, type ChannelNode, type GuildNode, type ListRoute, type MemberNode, type MembersRoute, type MessageNode, type MessagesRoute, type PageOptions, type Route, type RouteId, type RouteOptions, type UserNode, type WebhookNode, } from "./api.js";
+export { command, option, CommandRegistry, type ChannelConfig, type ChoiceConfig, type BooleanConfig, type Command, type CommandContext, type CommandDefinition, type MentionableValue, type NumberConfig, type OptionDef, type OptionMap, type OptionValues, type StringConfig, } from "./commands.js";
+export { channelCreatePayload, type CreateCategoryChannel, type CreateChannelOptions, type CreateForumChannel, type CreateTextChannel, type CreateVoiceChannel, type ForumTagInput, } from "./channel-create.js";
+export { ChannelHandle, GuildHandle, MemberHandle, MessageHandle, RoleHandle, UserHandle, parseDuration, type Duration, type Handle, type MessageInput, } from "./handles.js";
 export { GatewayIntentBits, IntentBits, Intents, IntentsBitField, resolveGatewayIntents, type GatewayIntentResolvable, } from "@lunibee/types";
-import { ApplicationCommandManager, ChannelManager, GuildManager, MonetizationManager, StageInstanceManager, UserManager } from "@lunibee/managers";
+import { ApplicationCommandManager, ChannelManager, GuildManager, MonetizationManager, ApplicationEmojiManager, StageInstanceManager, UserManager } from "@lunibee/managers";
 import { REST } from "@lunibee/rest";
 import { type InteractionClient, type ResourceContext } from "@lunibee/structures";
 import { Gateway } from "@lunibee/ws";
@@ -12,6 +16,9 @@ import type { APISoundboardSound, ClientOptions, ClientUser } from "@lunibee/typ
 import { type ClientEvents } from "./events.js";
 import { Collector, type CollectorOptions } from "./collector.js";
 import { PermissionSet } from "./permissions.js";
+import { type Api } from "./api.js";
+import { CommandRegistry } from "./commands.js";
+import { ChannelHandle, GuildHandle, MemberHandle, MessageHandle, RoleHandle, UserHandle } from "./handles.js";
 /** Lifecycle state of a client. */
 export type ClientState = "idle" | "connecting" | "ready" | "destroyed";
 type Listener<T extends unknown[]> = (...args: T) => unknown;
@@ -20,6 +27,8 @@ declare class EventEmitter<Events extends {
     [K in keyof Events]: unknown[];
 }> {
     #private;
+    /** Removes secrets from text this emitter prints; the client removes its token. */
+    protected readonly redactSecrets: (text: string) => string;
     on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
     once<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
     off<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
@@ -41,8 +50,17 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     readonly application: {
         commands: ApplicationCommandManager;
     };
+    /**
+     * Discord's REST API as a chained path: `bot.api.guilds(id).members(userId).patch({ nick })`.
+     * Uses this client's rate limiting and retries; `bot.rest` and `Routes` stay available.
+     */
+    get api(): Api;
+    /** Slash and prefix commands made with `command()`: `add`, `deploy` and `listen`. */
+    readonly commands: CommandRegistry;
     /** SKUs, entitlements and subscriptions; available after READY (application ID known). */
     monetization?: MonetizationManager;
+    /** The application's own emojis; available after READY (application ID known). */
+    applicationEmojis?: ApplicationEmojiManager;
     get ws(): Gateway;
     get gateway(): Gateway;
     user?: ClientUser;
@@ -52,6 +70,8 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
      * The bot token this client is authenticated with, or `null` once the
      * client has been destroyed. Mirrors `Client#token` in Discord.js.
      */
+    /** Replaces the bot token in text Lunibee prints (listener warnings). */
+    protected readonly redactSecrets: (text: string) => string;
     get token(): string | null;
     get uptime(): number | null;
     get ping(): number;
@@ -59,8 +79,32 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     isReady(): boolean;
     /** Sets the bot's presence / status. @param data Presence payload. @returns Whether the payload was sent. */
     setPresence(data: import("@lunibee/types").GatewayPresence): boolean;
+    /**
+     * Sets what the bot is doing: "Playing chess", "Watching the logs". Pass
+     * `null` to clear it. For a custom status (type `ActivityEnum.Custom`) the
+     * text shown is `state`, so it is set to `name` unless you give one.
+     * @example bot.setActivity("the logs", { type: ActivityEnum.Watching, status: "idle" });
+     * @returns Whether the update was sent (false while the Gateway is not connected).
+     */
+    setActivity(name: string | null, options?: {
+        type?: import("@lunibee/types").ActivityEnum;
+        url?: string;
+        state?: string;
+        status?: import("@lunibee/types").GatewayPresence["status"];
+    }): boolean;
     /** Sends a voice state update. @param data Voice state payload. @returns Whether it was sent. */
     setVoiceState(data: Record<string, unknown>): boolean;
+    /**
+     * Joins, moves or leaves a voice channel (op 4). Stable public voice API.
+     * Returns `false` (never throws) when disconnected, rate limited, or when
+     * the guild belongs to another shard of a sharded setup.
+     * @param guildId Guild snowflake. @param channelId Channel to join or move to; `null` leaves.
+     * @param options `selfMute` and `selfDeaf`. @returns Whether it was sent.
+     */
+    sendVoiceState(guildId: string, channelId: string | null, options?: {
+        selfMute?: boolean;
+        selfDeaf?: boolean;
+    }): boolean;
     /** Requests guild members. @param data Guild member request payload. @returns Whether it was sent. */
     requestGuildMembers(data: Record<string, unknown>): boolean;
     constructor(options: ClientOptions);
@@ -72,6 +116,24 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     createCollector<E extends keyof ClientEvents>(event: E, options?: CollectorOptions<ClientEvents[E][0]> & {
         key?: (item: ClientEvents[E][0]) => string;
     }): Collector<string, ClientEvents[E][0]>;
+    /**
+     * Names a guild by id. The handle reads it (`peek()` from the cache, `get()`
+     * from the cache or Discord, `fetch()` from Discord) and acts on it.
+     */
+    guild(id: string): GuildHandle;
+    /** Names a channel by id; see {@link Client.guild} for the read methods. */
+    channel(id: string): ChannelHandle;
+    /**
+     * Names a user by id; see {@link Client.guild} for the read methods.
+     * (`bot.user` is the bot's own account, hence the different name.)
+     */
+    person(id: string): UserHandle;
+    /** Names a guild member by guild id and user id. */
+    member(guildId: string, userId: string): MemberHandle;
+    /** Names a role by guild id and role id. */
+    role(guildId: string, roleId: string): RoleHandle;
+    /** Names a message by channel id and message id. */
+    message(channelId: string, messageId: string): MessageHandle;
     /** Structures built by this client (members from interactions...) act through this. */
     get resourceContext(): ResourceContext;
     /**
@@ -82,6 +144,10 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     permissionsFor(memberId: string, guildOrChannelId: string): PermissionSet | null;
     /** Fetches Discord's default soundboard sounds. */
     fetchDefaultSoundboardSounds(): Promise<APISoundboardSound[]>;
+    /**
+     * Connects to the Gateway. Resolves with the token used, like discord.js;
+     * do not log the return value.
+     */
     login(token?: string): Promise<string>;
     /**
      * Destroys the client, permanently closing the Gateway connection.
@@ -101,8 +167,6 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     /** Fetches an invite from Discord. */
     fetchInvite(code: string, options?: {
         withCounts?: boolean;
-        /** @deprecated No effect: Discord always returns `expires_at` and deprecated `with_expiration`. Removed in 0.3.0. */
-        withExpiration?: boolean;
         guildScheduledEventId?: string;
     }): Promise<Record<string, unknown>>;
     /** Fetches a sticker from Discord. */