chapterjs 0.0.0 → 0.1.1

package/dist/structures/Member.js

@@ -0,0 +1,124 @@
+import { Guild } from './Guild.js';
+import { User } from './User.js';
+import { cdnUrl, toDate, } from './utils.js';
+/** Longest timeout Discord accepts: 28 days. */
+const MAX_TIMEOUT = 28 * 24 * 60 * 60 * 1000;
+/**
+ * A user in a server.
+ * https://docs.discord.com/developers/resources/guild#guild-member-object
+ */
+export class Member {
+    client;
+    guildId;
+    raw;
+    id;
+    user;
+    /** Nickname in this server. */
+    nick;
+    /** Role ids, without the @everyone role. */
+    roles;
+    joinedAt;
+    /** When the member started boosting the server. */
+    premiumSince;
+    /** True until the member passes Membership Screening. */
+    pending;
+    /** Server avatar hash, if the member set one. */
+    avatar;
+    /** End of the member's timeout, null when not timed out. */
+    communicationDisabledUntil;
+    /** Permissions in the channel, sent with interactions only. */
+    permissions;
+    constructor(client, guildId, raw) {
+        this.client = client;
+        this.guildId = guildId;
+        this.raw = raw;
+        this.user = new User(client, raw.user);
+        this.id = this.user.id;
+        this.nick = raw.nick ?? null;
+        this.roles = raw.roles;
+        this.joinedAt = toDate(raw.joined_at);
+        this.premiumSince = toDate(raw.premium_since);
+        this.pending = raw.pending ?? false;
+        this.avatar = raw.avatar ?? null;
+        this.communicationDisabledUntil = toDate(raw.communication_disabled_until);
+        this.permissions = raw.permissions;
+    }
+    get guild() {
+        return new Guild(this.client, { id: this.guildId });
+    }
+    /** Name shown in this server: nickname, display name or username. */
+    get displayName() {
+        return this.nick ?? this.user.displayName;
+    }
+    get isTimedOut() {
+        return (this.communicationDisabledUntil?.getTime() ?? 0) > Date.now();
+    }
+    hasRole(roleId) {
+        return this.roles.includes(roleId);
+    }
+    /** Mention, e.g. `${member}` in a message. */
+    toString() {
+        return `<@${this.id}>`;
+    }
+    // https://docs.discord.com/developers/reference#image-formatting-cdn-endpoints
+    /** Avatar shown in this server: server avatar, user avatar or default avatar. */
+    displayAvatarURL(options) {
+        return this.avatar
+            ? cdnUrl(`guilds/${this.guildId}/users/${this.id}/avatars`, this.avatar, options)
+            : this.user.displayAvatarURL(options);
+    }
+    /** Sends a direct message. */
+    send(options) {
+        return this.user.send(options);
+    }
+    kick(reason) {
+        return this.guild.kick(this.id, reason);
+    }
+    ban(options) {
+        return this.guild.ban(this.id, options);
+    }
+    /**
+     * Times the member out for `duration` milliseconds (up to 28 days), or
+     * removes the timeout with null.
+     * https://docs.discord.com/developers/resources/guild#modify-guild-member
+     */
+    timeout(duration, reason) {
+        if (duration !== null && !(duration > 0 && duration <= MAX_TIMEOUT)) {
+            return Promise.reject(new Error(`timeout(): duration is ${duration}, it must be a number of milliseconds between 1 and 28 days, ` +
+                'e.g. 10 * 60_000 for 10 minutes (or null to remove the timeout).'));
+        }
+        const until = duration === null ? null : new Date(Date.now() + duration).toISOString();
+        return this.edit({ communication_disabled_until: until }, reason);
+    }
+    /** Null removes the nickname. */
+    setNickname(nick, reason) {
+        return this.edit({ nick }, reason);
+    }
+    /** https://docs.discord.com/developers/resources/guild#add-guild-member-role */
+    async addRole(roleId, reason) {
+        await this.client.rest.put(`/guilds/${this.guildId}/members/${this.id}/roles/${roleId}`, {
+            reason,
+        });
+    }
+    /** https://docs.discord.com/developers/resources/guild#remove-guild-member-role */
+    async removeRole(roleId, reason) {
+        await this.client.rest.delete(`/guilds/${this.guildId}/members/${this.id}/roles/${roleId}`, {
+            reason,
+        });
+    }
+    /**
+     * Updates the member with fields of the documented JSON params (snake_case:
+     * nick, roles, mute, deaf, channel_id, communication_disabled_until, flags).
+     * https://docs.discord.com/developers/resources/guild#modify-guild-member
+     */
+    async edit(data, reason) {
+        const member = await this.client.rest.patch(`/guilds/${this.guildId}/members/${this.id}`, { body: data, reason });
+        return new Member(this.client, this.guildId, {
+            ...member,
+            user: member.user ?? this.raw.user,
+        });
+    }
+    async fetch() {
+        return this.guild.fetchMember(this.id);
+    }
+}

package/dist/structures/Message.d.ts

@@ -0,0 +1,87 @@
+import type { Client } from '../discord/client.js';
+import type { APIMessage, Snowflake } from '../discord/types.js';
+import { Channel, type CreateThreadOptions } from './Channel.js';
+import { Guild } from './Guild.js';
+import { Member } from './Member.js';
+import { User } from './User.js';
+import { type MessageOptions, type ReplyOptions } from './utils.js';
+/** A unicode emoji (`'👍'`), a custom one (`'<:name:id>'` or `'name:id'`) or an emoji object. */
+export type EmojiResolvable = string | {
+    id: Snowflake | null;
+    name: string | null;
+};
+/**
+ * A message. `raw` holds every field sent by Discord (embeds, components,
+ * attachments…).
+ * https://docs.discord.com/developers/resources/message#message-object
+ */
+export declare class Message {
+    #private;
+    readonly client: Client;
+    readonly raw: APIMessage;
+    readonly id: Snowflake;
+    readonly channelId: Snowflake;
+    /** Null in DMs and for ephemeral messages. */
+    readonly guildId: Snowflake | null;
+    /** For webhook messages, holds the webhook's id, username and avatar. */
+    readonly author: User;
+    /** Author as a server member. Null in DMs, for webhooks and ephemeral messages. */
+    readonly member: Member | null;
+    /** Empty without the MessageContent intent, except in DMs and when the bot is mentioned. */
+    readonly content: string;
+    readonly createdAt: Date;
+    readonly editedAt: Date | null;
+    readonly tts: boolean;
+    readonly pinned: boolean;
+    /** https://docs.discord.com/developers/resources/message#message-object-message-types */
+    readonly type: number;
+    /** https://docs.discord.com/developers/resources/message#message-object-message-flags */
+    readonly flags: number;
+    readonly webhookId: Snowflake | null;
+    readonly mentions: User[];
+    readonly mentionRoles: Snowflake[];
+    readonly mentionEveryone: boolean;
+    /** https://docs.discord.com/developers/resources/message#attachment-object */
+    readonly attachments: unknown[];
+    /** https://docs.discord.com/developers/resources/message#embed-object */
+    readonly embeds: unknown[];
+    readonly components: unknown[];
+    /** Message replied to: null if it was deleted, undefined if not a reply or not sent. */
+    readonly referencedMessage: Message | null | undefined;
+    constructor(client: Client, raw: APIMessage);
+    get channel(): Channel;
+    /** Server of the message, null in DMs. */
+    get guild(): Guild | null;
+    get url(): string;
+    /**
+     * Replies to the message.
+     * https://docs.discord.com/developers/resources/message#message-reference-structure
+     */
+    reply(options: ReplyOptions): Promise<Message>;
+    /** Only the bot's own messages can have their content edited. https://docs.discord.com/developers/resources/message#edit-message */
+    edit(options: MessageOptions): Promise<Message>;
+    /** https://docs.discord.com/developers/resources/message#delete-message */
+    delete(reason?: string): Promise<void>;
+    /** https://docs.discord.com/developers/resources/message#create-reaction */
+    react(emoji: EmojiResolvable): Promise<void>;
+    /**
+     * Removes the bot's reaction, or the reaction of `userId`.
+     * https://docs.discord.com/developers/resources/message#delete-user-reaction
+     */
+    removeReaction(emoji: EmojiResolvable, userId?: Snowflake): Promise<void>;
+    /**
+     * Removes every reaction, or every reaction with `emoji`.
+     * https://docs.discord.com/developers/resources/message#delete-all-reactions
+     */
+    removeAllReactions(emoji?: EmojiResolvable): Promise<void>;
+    /** https://docs.discord.com/developers/resources/message#pin-message */
+    pin(reason?: string): Promise<void>;
+    /** https://docs.discord.com/developers/resources/message#unpin-message */
+    unpin(reason?: string): Promise<void>;
+    /** Publishes a message of an announcement channel to the following servers. */
+    crosspost(): Promise<Message>;
+    /** https://docs.discord.com/developers/resources/channel#start-thread-from-message */
+    startThread(options: Omit<CreateThreadOptions, 'type' | 'invitable'>): Promise<Channel>;
+    /** https://docs.discord.com/developers/resources/message#get-channel-message */
+    fetch(): Promise<Message>;
+}

package/dist/structures/Message.js

@@ -0,0 +1,182 @@
+var _a;
+import { Channel, toThreadBody } from './Channel.js';
+import { Guild } from './Guild.js';
+import { Member } from './Member.js';
+import { User } from './User.js';
+import { encodeEmoji, toAllowedMentions, toDate, toMessageBody, } from './utils.js';
+/**
+ * A message. `raw` holds every field sent by Discord (embeds, components,
+ * attachments…).
+ * https://docs.discord.com/developers/resources/message#message-object
+ */
+export class Message {
+    client;
+    raw;
+    id;
+    channelId;
+    /** Null in DMs and for ephemeral messages. */
+    guildId;
+    /** For webhook messages, holds the webhook's id, username and avatar. */
+    author;
+    /** Author as a server member. Null in DMs, for webhooks and ephemeral messages. */
+    member;
+    /** Empty without the MessageContent intent, except in DMs and when the bot is mentioned. */
+    content;
+    createdAt;
+    editedAt;
+    tts;
+    pinned;
+    /** https://docs.discord.com/developers/resources/message#message-object-message-types */
+    type;
+    /** https://docs.discord.com/developers/resources/message#message-object-message-flags */
+    flags;
+    webhookId;
+    mentions;
+    mentionRoles;
+    mentionEveryone;
+    /** https://docs.discord.com/developers/resources/message#attachment-object */
+    attachments;
+    /** https://docs.discord.com/developers/resources/message#embed-object */
+    embeds;
+    components;
+    /** Message replied to: null if it was deleted, undefined if not a reply or not sent. */
+    referencedMessage;
+    constructor(client, raw) {
+        this.client = client;
+        this.raw = raw;
+        this.id = raw.id;
+        this.channelId = raw.channel_id;
+        this.guildId = raw.guild_id ?? null;
+        this.author = new User(client, raw.author);
+        this.member =
+            raw.member && this.guildId
+                ? new Member(client, this.guildId, { ...raw.member, user: raw.author })
+                : null;
+        this.content = raw.content;
+        this.createdAt = new Date(raw.timestamp);
+        this.editedAt = toDate(raw.edited_timestamp);
+        this.tts = raw.tts;
+        this.pinned = raw.pinned;
+        this.type = raw.type;
+        this.flags = raw.flags ?? 0;
+        this.webhookId = raw.webhook_id ?? null;
+        this.mentions = (raw.mentions ?? []).map(user => new User(client, user));
+        this.mentionRoles = raw.mention_roles ?? [];
+        this.mentionEveryone = raw.mention_everyone;
+        this.attachments = raw.attachments ?? [];
+        this.embeds = raw.embeds ?? [];
+        this.components = raw.components ?? [];
+        this.referencedMessage = raw.referenced_message
+            ? new _a(client, {
+                guild_id: raw.guild_id,
+                ...raw.referenced_message,
+            })
+            : raw.referenced_message;
+    }
+    get channel() {
+        return new Channel(this.client, {
+            id: this.channelId,
+            ...(this.guildId && { guild_id: this.guildId }),
+        });
+    }
+    /** Server of the message, null in DMs. */
+    get guild() {
+        return this.guildId ? new Guild(this.client, { id: this.guildId }) : null;
+    }
+    get url() {
+        return `https://discord.com/channels/${this.guildId ?? '@me'}/${this.channelId}/${this.id}`;
+    }
+    #path(suffix = '') {
+        return `/channels/${this.channelId}/messages/${this.id}${suffix}`;
+    }
+    #wrap(message) {
+        return new _a(this.client, {
+            guild_id: this.guildId ?? undefined,
+            ...message,
+        });
+    }
+    /**
+     * Replies to the message.
+     * https://docs.discord.com/developers/resources/message#message-reference-structure
+     */
+    async reply(options) {
+        const { body, files } = toMessageBody(options);
+        const reply = typeof options === 'string' ? {} : options;
+        body.message_reference = {
+            message_id: this.id,
+            channel_id: this.channelId,
+            ...(this.guildId && { guild_id: this.guildId }),
+            ...(reply.failIfNotExists !== undefined && {
+                fail_if_not_exists: reply.failIfNotExists,
+            }),
+        };
+        if (reply.mention !== undefined) {
+            body.allowed_mentions = {
+                // Without allowed_mentions, regular messages parse every mention type
+                ...(reply.allowedMentions
+                    ? toAllowedMentions(reply.allowedMentions)
+                    : { parse: ['users', 'roles', 'everyone'] }),
+                replied_user: reply.mention,
+            };
+        }
+        return this.#wrap(await this.client.rest.post(`/channels/${this.channelId}/messages`, {
+            body,
+            files,
+        }));
+    }
+    /** Only the bot's own messages can have their content edited. https://docs.discord.com/developers/resources/message#edit-message */
+    async edit(options) {
+        const { body, files } = toMessageBody(options);
+        return this.#wrap(await this.client.rest.patch(this.#path(), { body, files }));
+    }
+    /** https://docs.discord.com/developers/resources/message#delete-message */
+    async delete(reason) {
+        await this.client.rest.delete(this.#path(), { reason });
+    }
+    /** https://docs.discord.com/developers/resources/message#create-reaction */
+    async react(emoji) {
+        await this.client.rest.put(this.#path(`/reactions/${encodeEmoji(emoji)}/@me`));
+    }
+    /**
+     * Removes the bot's reaction, or the reaction of `userId`.
+     * https://docs.discord.com/developers/resources/message#delete-user-reaction
+     */
+    async removeReaction(emoji, userId) {
+        await this.client.rest.delete(this.#path(`/reactions/${encodeEmoji(emoji)}/${userId ?? '@me'}`));
+    }
+    /**
+     * Removes every reaction, or every reaction with `emoji`.
+     * https://docs.discord.com/developers/resources/message#delete-all-reactions
+     */
+    async removeAllReactions(emoji) {
+        await this.client.rest.delete(this.#path(emoji ? `/reactions/${encodeEmoji(emoji)}` : '/reactions'));
+    }
+    /** https://docs.discord.com/developers/resources/message#pin-message */
+    async pin(reason) {
+        await this.client.rest.put(`/channels/${this.channelId}/messages/pins/${this.id}`, { reason });
+    }
+    /** https://docs.discord.com/developers/resources/message#unpin-message */
+    async unpin(reason) {
+        await this.client.rest.delete(`/channels/${this.channelId}/messages/pins/${this.id}`, {
+            reason,
+        });
+    }
+    /** Publishes a message of an announcement channel to the following servers. */
+    async crosspost() {
+        return this.#wrap(await this.client.rest.post(this.#path('/crosspost')));
+    }
+    /** https://docs.discord.com/developers/resources/channel#start-thread-from-message */
+    async startThread(options) {
+        const { reason, ...thread } = options;
+        const channel = await this.client.rest.post(this.#path('/threads'), {
+            body: toThreadBody(thread),
+            reason,
+        });
+        return new Channel(this.client, channel);
+    }
+    /** https://docs.discord.com/developers/resources/message#get-channel-message */
+    async fetch() {
+        return this.#wrap(await this.client.rest.get(this.#path()));
+    }
+}
+_a = Message;

package/dist/structures/Reaction.d.ts

@@ -0,0 +1,38 @@
+import type { Client } from '../discord/client.js';
+import type { APIMessageReactionAddEvent, PartialEmoji, Snowflake } from '../discord/types.js';
+import { Channel } from './Channel.js';
+import { Guild } from './Guild.js';
+import { Member } from './Member.js';
+import type { Message } from './Message.js';
+/**
+ * A reaction added or removed by a user.
+ * https://docs.discord.com/developers/events/gateway-events#message-reaction-add
+ */
+export declare class Reaction {
+    readonly client: Client;
+    readonly raw: Omit<APIMessageReactionAddEvent, 'member'> & {
+        member?: APIMessageReactionAddEvent['member'];
+    };
+    readonly emoji: PartialEmoji;
+    readonly userId: Snowflake;
+    readonly messageId: Snowflake;
+    readonly channelId: Snowflake;
+    readonly guildId: Snowflake | null;
+    /** Member who reacted, sent with reactions added in a server. */
+    readonly member: Member | null;
+    /** Author of the message, sent with reactions added. */
+    readonly messageAuthorId: Snowflake | null;
+    /** True for a super reaction. */
+    readonly burst: boolean;
+    constructor(client: Client, raw: Omit<APIMessageReactionAddEvent, 'member'> & {
+        member?: APIMessageReactionAddEvent['member'];
+    });
+    get channel(): Channel;
+    get guild(): Guild | null;
+    /** `👍` or `<:name:id>`, as written in a message. */
+    toString(): string;
+    /** The reacted message. */
+    fetchMessage(): Promise<Message>;
+    /** Removes this user's reaction. https://docs.discord.com/developers/resources/message#delete-user-reaction */
+    remove(): Promise<void>;
+}

package/dist/structures/Reaction.js

@@ -0,0 +1,64 @@
+import { Channel } from './Channel.js';
+import { Guild } from './Guild.js';
+import { Member } from './Member.js';
+import { encodeEmoji } from './utils.js';
+/**
+ * A reaction added or removed by a user.
+ * https://docs.discord.com/developers/events/gateway-events#message-reaction-add
+ */
+export class Reaction {
+    client;
+    raw;
+    emoji;
+    userId;
+    messageId;
+    channelId;
+    guildId;
+    /** Member who reacted, sent with reactions added in a server. */
+    member;
+    /** Author of the message, sent with reactions added. */
+    messageAuthorId;
+    /** True for a super reaction. */
+    burst;
+    constructor(client, raw) {
+        this.client = client;
+        this.raw = raw;
+        this.emoji = raw.emoji;
+        this.userId = raw.user_id;
+        this.messageId = raw.message_id;
+        this.channelId = raw.channel_id;
+        this.guildId = raw.guild_id ?? null;
+        this.member =
+            raw.member?.user && this.guildId
+                ? new Member(client, this.guildId, {
+                    ...raw.member,
+                    user: raw.member.user,
+                })
+                : null;
+        this.messageAuthorId = raw.message_author_id ?? null;
+        this.burst = raw.burst;
+    }
+    get channel() {
+        return new Channel(this.client, {
+            id: this.channelId,
+            ...(this.guildId && { guild_id: this.guildId }),
+        });
+    }
+    get guild() {
+        return this.guildId ? new Guild(this.client, { id: this.guildId }) : null;
+    }
+    /** `👍` or `<:name:id>`, as written in a message. */
+    toString() {
+        const { id, name, animated } = this.emoji;
+        return id ? `<${animated ? 'a' : ''}:${name}:${id}>` : (name ?? '');
+    }
+    /** The reacted message. */
+    fetchMessage() {
+        return this.channel.fetchMessage(this.messageId);
+    }
+    /** Removes this user's reaction. https://docs.discord.com/developers/resources/message#delete-user-reaction */
+    async remove() {
+        const user = this.userId === this.client.user?.id ? '@me' : this.userId;
+        await this.client.rest.delete(`/channels/${this.channelId}/messages/${this.messageId}/reactions/${encodeEmoji(this.emoji)}/${user}`);
+    }
+}

package/dist/structures/Role.d.ts

@@ -0,0 +1,43 @@
+import type { Client } from '../discord/client.js';
+import type { APIRole, Snowflake } from '../discord/types.js';
+import { Guild } from './Guild.js';
+import { type ImageOptions } from './utils.js';
+/**
+ * A server role.
+ * https://docs.discord.com/developers/topics/permissions#role-object
+ */
+export declare class Role {
+    readonly client: Client;
+    readonly guildId: Snowflake;
+    readonly raw: APIRole;
+    readonly id: Snowflake;
+    readonly name: string;
+    /** Primary color as an integer, 0 when the role has none. */
+    readonly color: number;
+    /** Shown separately in the member list. */
+    readonly hoist: boolean;
+    readonly position: number;
+    /** Permission bit set, as a string since it doesn't fit in a number. */
+    readonly permissions: string;
+    /** Managed by an integration (bot role, boosters…): can't be assigned. */
+    readonly managed: boolean;
+    readonly mentionable: boolean;
+    readonly icon: string | null;
+    readonly unicodeEmoji: string | null;
+    constructor(client: Client, guildId: Snowflake, raw: APIRole);
+    get guild(): Guild;
+    /** The @everyone role has the guild's id. */
+    get isEveryone(): boolean;
+    /** Whether the role grants a permission, e.g. `1n << 3n` (ADMINISTRATOR). */
+    has(permission: bigint): boolean;
+    /** Mention, e.g. `${role}` in a message. */
+    toString(): string;
+    iconURL(options?: ImageOptions): string | null;
+    /**
+     * Updates the role with fields of the documented JSON params (snake_case).
+     * https://docs.discord.com/developers/resources/guild#modify-guild-role
+     */
+    edit(data: Record<string, unknown>, reason?: string): Promise<Role>;
+    /** https://docs.discord.com/developers/resources/guild#delete-guild-role */
+    delete(reason?: string): Promise<void>;
+}

package/dist/structures/Role.js

@@ -0,0 +1,77 @@
+import { Guild } from './Guild.js';
+import { cdnUrl } from './utils.js';
+/**
+ * A server role.
+ * https://docs.discord.com/developers/topics/permissions#role-object
+ */
+export class Role {
+    client;
+    guildId;
+    raw;
+    id;
+    name;
+    /** Primary color as an integer, 0 when the role has none. */
+    color;
+    /** Shown separately in the member list. */
+    hoist;
+    position;
+    /** Permission bit set, as a string since it doesn't fit in a number. */
+    permissions;
+    /** Managed by an integration (bot role, boosters…): can't be assigned. */
+    managed;
+    mentionable;
+    icon;
+    unicodeEmoji;
+    constructor(client, guildId, raw) {
+        this.client = client;
+        this.guildId = guildId;
+        this.raw = raw;
+        this.id = raw.id;
+        this.name = raw.name;
+        this.color = raw.colors?.primary_color ?? raw.color;
+        this.hoist = raw.hoist;
+        this.position = raw.position;
+        this.permissions = raw.permissions;
+        this.managed = raw.managed;
+        this.mentionable = raw.mentionable;
+        this.icon = raw.icon ?? null;
+        this.unicodeEmoji = raw.unicode_emoji ?? null;
+    }
+    get guild() {
+        return new Guild(this.client, { id: this.guildId });
+    }
+    /** The @everyone role has the guild's id. */
+    get isEveryone() {
+        return this.id === this.guildId;
+    }
+    /** Whether the role grants a permission, e.g. `1n << 3n` (ADMINISTRATOR). */
+    has(permission) {
+        return (BigInt(this.permissions) & permission) === permission;
+    }
+    /** Mention, e.g. `${role}` in a message. */
+    toString() {
+        return this.isEveryone ? '@everyone' : `<@&${this.id}>`;
+    }
+    iconURL(options) {
+        return this.icon
+            ? cdnUrl(`role-icons/${this.id}`, this.icon, options)
+            : null;
+    }
+    /**
+     * Updates the role with fields of the documented JSON params (snake_case).
+     * https://docs.discord.com/developers/resources/guild#modify-guild-role
+     */
+    async edit(data, reason) {
+        const role = await this.client.rest.patch(`/guilds/${this.guildId}/roles/${this.id}`, {
+            body: data,
+            reason,
+        });
+        return new Role(this.client, this.guildId, role);
+    }
+    /** https://docs.discord.com/developers/resources/guild#delete-guild-role */
+    async delete(reason) {
+        await this.client.rest.delete(`/guilds/${this.guildId}/roles/${this.id}`, {
+            reason,
+        });
+    }
+}

package/dist/structures/User.d.ts

@@ -0,0 +1,41 @@
+import type { Client } from '../discord/client.js';
+import type { APIUser, Snowflake } from '../discord/types.js';
+import type { Message } from './Message.js';
+import { type ImageOptions, type MessageOptions } from './utils.js';
+/**
+ * A Discord user. `raw` holds every field sent by Discord.
+ * https://docs.discord.com/developers/resources/user#user-object
+ */
+export declare class User {
+    readonly client: Client;
+    readonly raw: APIUser;
+    readonly id: Snowflake;
+    readonly username: string;
+    /** Display name set by the user, if any. */
+    readonly globalName: string | null;
+    readonly discriminator: string;
+    readonly avatar: string | null;
+    readonly banner: string | null;
+    readonly bot: boolean;
+    readonly system: boolean;
+    constructor(client: Client, raw: APIUser);
+    /** Name shown in Discord: the display name, or the username. */
+    get displayName(): string;
+    get createdAt(): Date;
+    /** Mention, e.g. `${user}` in a message. */
+    toString(): string;
+    /** Uploaded avatar, or null when the user has none. */
+    avatarURL(options?: ImageOptions): string | null;
+    /** Default avatar Discord shows when the user has none. */
+    get defaultAvatarURL(): string;
+    /** Avatar shown in Discord: the uploaded one, or the default one. */
+    displayAvatarURL(options?: ImageOptions): string;
+    bannerURL(options?: ImageOptions): string | null;
+    /**
+     * Sends a direct message, opening the DM channel (or reusing it).
+     * https://docs.discord.com/developers/resources/user#create-dm
+     */
+    send(options: MessageOptions): Promise<Message>;
+    /** Latest data from Discord. */
+    fetch(): Promise<User>;
+}