elynn-baileys 1.0.1

package/lib/Discord/structures/ThreadOnlyChannel.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module ThreadOnlyChannel */
+const GuildChannel_1 = __importDefault(require("./GuildChannel"));
+const PermissionOverwrite_1 = __importDefault(require("./PermissionOverwrite"));
+const Permission_1 = __importDefault(require("./Permission"));
+const TypedCollection_1 = __importDefault(require("../util/TypedCollection"));
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../util/Errors");
+const Collection_1 = __importDefault(require("../util/Collection"));
+/** Represents a thread only channel. */
+class ThreadOnlyChannel extends GuildChannel_1.default {
+    /** The usable tags for threads. */
+    availableTags;
+    /** The default auto archive duration for threads. */
+    defaultAutoArchiveDuration;
+    /** The default forum layout used to display threads. */
+    defaultForumLayout;
+    /** The default reaction emoji for threads. */
+    defaultReactionEmoji;
+    /** The default sort order mode used to sort threads. */
+    defaultSortOrder;
+    /** The default amount of seconds between non-moderators sending messages in threads. */
+    defaultThreadRateLimitPerUser;
+    /** The flags for this channel, see {@link Constants.ChannelFlags | ChannelFlags}. */
+    flags;
+    /** The ID of most recently created thread. */
+    lastThreadID;
+    /** If this channel is age gated. */
+    nsfw;
+    /** The permission overwrites of this channel. */
+    permissionOverwrites;
+    /** The position of this channel on the sidebar. */
+    position;
+    /** The amount of seconds between non-moderators creating threads. */
+    rateLimitPerUser;
+    /** The `guidelines` of this forum channel. */
+    topic;
+    constructor(data, client) {
+        super(data, client);
+        this.availableTags = [];
+        this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        this.defaultForumLayout = data.default_forum_layout;
+        this.defaultReactionEmoji = null;
+        this.defaultSortOrder = null;
+        this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user;
+        this.flags = data.flags;
+        this.lastThreadID = data.last_message_id;
+        this.nsfw = data.nsfw;
+        this.permissionOverwrites = new TypedCollection_1.default(PermissionOverwrite_1.default, client);
+        this.position = data.position;
+        this.rateLimitPerUser = data.rate_limit_per_user;
+        this.topic = data.topic;
+        this.update(data);
+    }
+    update(data) {
+        super.update(data);
+        if (data.available_tags !== undefined) {
+            this.availableTags = data.available_tags.map(tag => ({
+                emoji: tag.emoji_id === null && tag.emoji_name === null ? null : { id: tag.emoji_id, name: tag.emoji_name },
+                id: tag.id,
+                moderated: tag.moderated,
+                name: tag.name
+            }));
+        }
+        if (data.default_auto_archive_duration !== undefined) {
+            this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        }
+        if (data.default_forum_layout !== undefined) {
+            this.defaultForumLayout = data.default_forum_layout;
+        }
+        if (data.default_reaction_emoji !== undefined) {
+            this.defaultReactionEmoji = data.default_reaction_emoji === null || (data.default_reaction_emoji.emoji_id === null && data.default_reaction_emoji.emoji_name === null) ? null : { id: data.default_reaction_emoji.emoji_id, name: data.default_reaction_emoji.emoji_name };
+        }
+        if (data.default_sort_order !== undefined) {
+            this.defaultSortOrder = data.default_sort_order;
+        }
+        if (data.default_thread_rate_limit_per_user !== undefined) {
+            this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user;
+        }
+        if (data.flags !== undefined) {
+            this.flags = data.flags;
+        }
+        if (data.last_message_id !== undefined) {
+            this.lastThreadID = data.last_message_id;
+        }
+        if (data.nsfw !== undefined) {
+            this.nsfw = data.nsfw;
+        }
+        if (data.permission_overwrites !== undefined) {
+            for (const id of this.permissionOverwrites.keys()) {
+                if (!data.permission_overwrites.some(overwrite => overwrite.id === id)) {
+                    this.permissionOverwrites.delete(id);
+                }
+            }
+            for (const overwrite of data.permission_overwrites) {
+                this.permissionOverwrites.update(overwrite);
+            }
+        }
+        if (data.position !== undefined) {
+            this.position = data.position;
+        }
+        if (data.rate_limit_per_user !== undefined) {
+            this.rateLimitPerUser = data.rate_limit_per_user;
+        }
+        if (data.topic !== undefined && data.topic !== null) {
+            this.topic = data.topic;
+        }
+    }
+    /** The most recently created thread. */
+    get lastThread() {
+        return this.lastThreadID === null ? null : this.guild.threads.get(this.lastThreadID);
+    }
+    /** The threads in this channel. The returned collection is disposable. */
+    get threads() {
+        return new Collection_1.default(this.guild.threads.filter(thread => thread.parentID === this.id).map(thread => [thread.id, thread]));
+    }
+    /**
+     * Create an invite for this channel. If the guild is not a `COMMUNITY` server, invites can only be made to last 30 days.
+     * @param options The options for the invite.
+     */
+    async createInvite(options) {
+        return this.client.rest.channels.createInvite(this.id, options);
+    }
+    /**
+     * Create a webhook in this channel.
+     * @param options The options to create the webhook with.
+     */
+    async createWebhook(options) {
+        return this.client.rest.webhooks.create(this.id, options);
+    }
+    /**
+     * Delete a permission overwrite on this channel.
+     * @param overwriteID The ID of the permission overwrite to delete.
+     * @param reason The reason for deleting the permission overwrite.
+     */
+    async deletePermission(overwriteID, reason) {
+        return this.client.rest.channels.deletePermission(this.id, overwriteID, reason);
+    }
+    /**
+     * Edit a permission overwrite on this channel.
+     * @param overwriteID The ID of the permission overwrite to edit.
+     * @param options The options for editing the permission overwrite.
+     */
+    async editPermission(overwriteID, options) {
+        return this.client.rest.channels.editPermission(this.id, overwriteID, options);
+    }
+    /**
+     * Get the invites of this channel.
+     */
+    async getInvites() {
+        return this.client.rest.channels.getInvites(this.id);
+    }
+    /**
+     * Get the public archived threads in this channel.
+     * @param options The options for getting the public archived threads.
+     */
+    async getPublicArchivedThreads(options) {
+        return this.client.rest.channels.getPublicArchivedThreads(this.id, options);
+    }
+    /**
+     * Get the webhooks in this channel.
+     */
+    async getWebhooks() {
+        return this.client.rest.webhooks.getForChannel(this.id);
+    }
+    /**
+     * Get the permissions of a member.  If providing an id, the member must be cached.
+     * @param member The member to get the permissions of.
+     */
+    permissionsOf(member) {
+        if (typeof member === "string") {
+            member = this.guild.members.get(member);
+        }
+        if (!member) {
+            throw new Errors_1.UncachedError(`Cannot use ${this.constructor.name}#permissionsOf with an ID when the member is not cached.`);
+        }
+        let permission = this.guild.permissionsOf(member).allow;
+        if (permission & Constants_1.Permissions.ADMINISTRATOR) {
+            return new Permission_1.default(Constants_1.AllPermissions);
+        }
+        let overwrite = this.permissionOverwrites.get(this.guildID);
+        if (overwrite) {
+            permission = (permission & ~overwrite.deny) | overwrite.allow;
+        }
+        let deny = 0n;
+        let allow = 0n;
+        for (const id of member.roles) {
+            if ((overwrite = this.permissionOverwrites.get(id))) {
+                deny |= overwrite.deny;
+                allow |= overwrite.allow;
+            }
+        }
+        permission = (permission & ~deny) | allow;
+        overwrite = this.permissionOverwrites.get(member.id);
+        if (overwrite) {
+            permission = (permission & ~overwrite.deny) | overwrite.allow;
+        }
+        return new Permission_1.default(permission);
+    }
+    /**
+     * Create a thread in this forum channel.
+     * @param options The options for starting the thread.
+     */
+    async startThread(options) {
+        return this.client.rest.channels.startThreadInThreadOnlyChannel(this.id, options);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            availableTags: this.availableTags,
+            defaultAutoArchiveDuration: this.defaultAutoArchiveDuration,
+            defaultForumLayout: this.defaultForumLayout,
+            defaultReactionEmoji: this.defaultReactionEmoji,
+            defaultSortOrder: this.defaultSortOrder,
+            defaultThreadRateLimitPerUser: this.defaultThreadRateLimitPerUser,
+            flags: this.flags,
+            lastThreadID: this.lastThreadID,
+            permissionOverwrites: this.permissionOverwrites.map(overwrite => overwrite.toJSON()),
+            position: this.position,
+            rateLimitPerUser: this.rateLimitPerUser,
+            threads: this.threads.map(thread => thread.id),
+            topic: this.topic,
+            type: this.type
+        };
+    }
+}
+exports.default = ThreadOnlyChannel;

package/lib/Discord/structures/ThreadableChannel.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TextableChannel */
+const TextableChannel_1 = __importDefault(require("./TextableChannel.cjs"));
+const Collection_1 = __importDefault(require("../util/Collection.cjs"));
+/** Represents a guild textable channel. */
+class ThreadableChannel extends TextableChannel_1.default {
+    /** The default auto archive duration for threads created in this channel. */
+    defaultAutoArchiveDuration;
+    constructor(data, client) {
+        super(data, client);
+        this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        this.update(data);
+    }
+    update(data) {
+        super.update(data);
+        if (data.default_auto_archive_duration !== undefined) {
+            this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        }
+    }
+    /** The threads in this channel. The returned collection is disposable. */
+    get threads() {
+        return new Collection_1.default(this.guild.threads.filter(thread => thread.parentID === this.id).map(thread => [thread.id, thread]));
+    }
+    /**
+     * Get the public archived threads in this channel.
+     * @param options The options for getting the public archived threads.
+     */
+    async getPublicArchivedThreads(options) {
+        return this.client.rest.channels.getPublicArchivedThreads(this.id, options);
+    }
+    /**
+     * Create a thread from an existing message in this channel.
+     * @param messageID The ID of the message to create a thread from.
+     * @param options The options for creating the thread.
+     */
+    async startThreadFromMessage(messageID, options) {
+        return this.client.rest.channels.startThreadFromMessage(this.id, messageID, options);
+    }
+    /**
+     * Create a thread without an existing message in this channel.
+     * @param options The options for creating the thread.
+     */
+    async startThreadWithoutMessage(options) {
+        return this.client.rest.channels.startThreadWithoutMessage(this.id, options);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            defaultAutoArchiveDuration: this.defaultAutoArchiveDuration,
+            threads: this.threads.map(thread => thread.id),
+            type: this.type
+        };
+    }
+}
+exports.default = ThreadableChannel;

package/lib/Discord/structures/ThreadableChannel.d.ts

@@ -0,0 +1,35 @@
+/** @module TextableChannel */
+import TextableChannel from "./TextableChannel";
+import type PrivateThreadChannel from "./PrivateThreadChannel";
+import type * as Types from "../types/namespaced";
+import type { ChannelTypes, ThreadAutoArchiveDuration } from "../Constants";
+import type Client from "../Client";
+import Collection from "../util/Collection";
+/** Represents a guild textable channel. */
+export default class ThreadableChannel<TC extends Types.Channels.AnyTextableGuildChannel = Types.Channels.AnyTextableGuildChannel, TH extends Types.Channels.AnyThreadChannel = Types.Channels.AnyThreadChannel> extends TextableChannel<TC> {
+    /** The default auto archive duration for threads created in this channel. */
+    defaultAutoArchiveDuration: ThreadAutoArchiveDuration;
+    /** The threads in this channel. */
+    type: ChannelTypes.GUILD_TEXT | ChannelTypes.GUILD_ANNOUNCEMENT;
+    constructor(data: Types.Channels.RawTextChannel | Types.Channels.RawAnnouncementChannel, client: Client);
+    protected update(data: Partial<Types.Channels.RawTextChannel | Types.Channels.RawAnnouncementChannel>): void;
+    /** The threads in this channel. The returned collection is disposable. */
+    get threads(): Collection<string, TH>;
+    /**
+     * Get the public archived threads in this channel.
+     * @param options The options for getting the public archived threads.
+     */
+    getPublicArchivedThreads(options?: Types.Channels.GetArchivedThreadsOptions): Promise<Types.Channels.ArchivedThreads<Exclude<TH, PrivateThreadChannel>>>;
+    /**
+     * Create a thread from an existing message in this channel.
+     * @param messageID The ID of the message to create a thread from.
+     * @param options The options for creating the thread.
+     */
+    startThreadFromMessage(messageID: string, options: Types.Channels.StartThreadFromMessageOptions): Promise<TH>;
+    /**
+     * Create a thread without an existing message in this channel.
+     * @param options The options for creating the thread.
+     */
+    startThreadWithoutMessage(options: Types.Channels.StartThreadWithoutMessageOptions): Promise<TH>;
+    toJSON(): Types.JSON.JSONThreadableChannel;
+}

package/lib/Discord/structures/ThreadableChannel.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module TextableChannel */
+const TextableChannel_1 = __importDefault(require("./TextableChannel"));
+const Collection_1 = __importDefault(require("../util/Collection"));
+/** Represents a guild textable channel. */
+class ThreadableChannel extends TextableChannel_1.default {
+    /** The default auto archive duration for threads created in this channel. */
+    defaultAutoArchiveDuration;
+    constructor(data, client) {
+        super(data, client);
+        this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        this.update(data);
+    }
+    update(data) {
+        super.update(data);
+        if (data.default_auto_archive_duration !== undefined) {
+            this.defaultAutoArchiveDuration = data.default_auto_archive_duration;
+        }
+    }
+    /** The threads in this channel. The returned collection is disposable. */
+    get threads() {
+        return new Collection_1.default(this.guild.threads.filter(thread => thread.parentID === this.id).map(thread => [thread.id, thread]));
+    }
+    /**
+     * Get the public archived threads in this channel.
+     * @param options The options for getting the public archived threads.
+     */
+    async getPublicArchivedThreads(options) {
+        return this.client.rest.channels.getPublicArchivedThreads(this.id, options);
+    }
+    /**
+     * Create a thread from an existing message in this channel.
+     * @param messageID The ID of the message to create a thread from.
+     * @param options The options for creating the thread.
+     */
+    async startThreadFromMessage(messageID, options) {
+        return this.client.rest.channels.startThreadFromMessage(this.id, messageID, options);
+    }
+    /**
+     * Create a thread without an existing message in this channel.
+     * @param options The options for creating the thread.
+     */
+    async startThreadWithoutMessage(options) {
+        return this.client.rest.channels.startThreadWithoutMessage(this.id, options);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            defaultAutoArchiveDuration: this.defaultAutoArchiveDuration,
+            threads: this.threads.map(thread => thread.id),
+            type: this.type
+        };
+    }
+}
+exports.default = ThreadableChannel;

package/lib/Discord/structures/UnavailableGuild.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module UnavailableGuild */
+const Base_1 = __importDefault(require("./Base.cjs"));
+/** Represents a guild that is unavailable. */
+class UnavailableGuild extends Base_1.default {
+    unavailable;
+    constructor(data, client) {
+        super(data.id, client);
+        this.unavailable = data.unavailable;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            unavailable: this.unavailable
+        };
+    }
+}
+exports.default = UnavailableGuild;

package/lib/Discord/structures/UnavailableGuild.d.ts

@@ -0,0 +1,10 @@
+/** @module UnavailableGuild */
+import Base from "./Base";
+import type * as Types from "../types/namespaced";
+import type Client from "../Client";
+/** Represents a guild that is unavailable. */
+export default class UnavailableGuild extends Base {
+    unavailable: true;
+    constructor(data: Types.Guilds.RawUnavailableGuild, client: Client);
+    toJSON(): Types.JSON.JSONUnavailableGuild;
+}

package/lib/Discord/structures/UnavailableGuild.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module UnavailableGuild */
+const Base_1 = __importDefault(require("./Base"));
+/** Represents a guild that is unavailable. */
+class UnavailableGuild extends Base_1.default {
+    unavailable;
+    constructor(data, client) {
+        super(data.id, client);
+        this.unavailable = data.unavailable;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            unavailable: this.unavailable
+        };
+    }
+}
+exports.default = UnavailableGuild;

package/lib/Discord/structures/User.cjs

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module User */
+const Base_1 = __importDefault(require("./Base.cjs"));
+const PrimaryGuild_1 = __importDefault(require("./PrimaryGuild.cjs"));
+const Constants_1 = require("../Constants.cjs");
+const Routes = __importStar(require("../util/Routes.cjs"));
+const Errors_1 = require("../util/Errors.cjs");
+/** Represents a user. */
+class User extends Base_1.default {
+    /** The user's banner color. If this member was received via the gateway, this will never be present. */
+    accentColor;
+    /** The user's avatar hash. */
+    avatar;
+    /** The data for this user's avatar decoration. */
+    avatarDecorationData;
+    /** The user's banner hash. If this member was received via the gateway, this will never be present. */
+    banner;
+    /** If this user is a bot. */
+    bot;
+    /** The user's collectibles. */
+    collectibles;
+    /** The 4 digits after this user's username, if they have not been migrated. If migrated, this will be a single "0". */
+    discriminator;
+    displayNameStyles;
+    /** The user's display name, if set. */
+    globalName;
+    /** The primary guild this user is in. */
+    primaryGuild;
+    /** The user's public [flags](https://discord.com/developers/docs/resources/user#user-object-user-flags). */
+    publicFlags;
+    /** If this user is an official discord system user. */
+    system;
+    /** The user's username. */
+    username;
+    constructor(data, client) {
+        super(data.id, client);
+        this.avatar = null;
+        this.avatarDecorationData = null;
+        this.bot = !!data.bot;
+        this.collectibles = null;
+        this.discriminator = data.discriminator;
+        this.displayNameStyles = null;
+        this.globalName = data.global_name;
+        this.primaryGuild = null;
+        this.publicFlags = 0;
+        this.system = !!data.system;
+        this.username = data.username;
+        this.update(data);
+    }
+    update(data) {
+        if (data.accent_color !== undefined) {
+            this.accentColor = data.accent_color;
+        }
+        if (data.avatar !== undefined) {
+            this.avatar = data.avatar;
+        }
+        if (data.avatar_decoration_data !== undefined) {
+            this.avatarDecorationData = data.avatar_decoration_data ? {
+                asset: data.avatar_decoration_data.asset,
+                skuID: data.avatar_decoration_data.sku_id
+            } : null;
+        }
+        if (data.banner !== undefined) {
+            this.banner = data.banner;
+        }
+        if (data.collectibles !== undefined) {
+            this.collectibles = data.collectibles ? {
+                nameplate: data.collectibles.nameplate ? {
+                    asset: data.collectibles.nameplate.asset,
+                    label: data.collectibles.nameplate.label,
+                    palette: data.collectibles.nameplate.palette,
+                    skuID: data.collectibles.nameplate.sku_id
+                } : undefined
+            } : null;
+        }
+        if (data.discriminator !== undefined) {
+            this.discriminator = data.discriminator;
+        }
+        if (data.display_name_styles !== undefined) {
+            this.displayNameStyles = data.display_name_styles === null ? null : {
+                colors: data.display_name_styles.colors,
+                effectID: data.display_name_styles.effect_id,
+                fontID: data.display_name_styles.font_id
+            };
+        }
+        if (data.global_name !== undefined) {
+            this.globalName = data.global_name;
+        }
+        if (data.username !== undefined) {
+            this.username = data.username;
+        }
+        if (data.primary_guild !== undefined) {
+            this.primaryGuild = data.primary_guild ? new PrimaryGuild_1.default(data.primary_guild, this.client) : null;
+        }
+    }
+    /**
+     * The primary guild this user is in.
+     * @deprecated Use {@link primaryGuild}
+     */
+    get clan() {
+        return this.primaryGuild;
+    }
+    /** The default avatar value of this user. */
+    get defaultAvatar() {
+        if (this.isMigrated) {
+            return Number(BigInt(this.id) >> 22n) % 6;
+        }
+        return Number(this.discriminator) % 5;
+    }
+    /** If this user has migrated to the new username system. */
+    get isMigrated() {
+        return (this.discriminator === undefined || this.discriminator === "0");
+    }
+    /** A string that will mention this user. */
+    get mention() {
+        return `<@${this.id}>`;
+    }
+    /** This user's unique username, if migrated, else a combination of the user's username and discriminator. */
+    get tag() {
+        if (this.isMigrated) {
+            return this.username;
+        }
+        return `${this.username}#${this.discriminator}`;
+    }
+    /**
+     * The url of this user's avatar decoration. This will always be a png.
+     * Discord does not combine the decoration and their current avatar for you. This is ONLY the decoration.
+     * @param size The dimensions of the image.
+     */
+    avatarDecorationURL(size) {
+        return this.avatarDecorationData ? this.client.util.formatImage(Routes.AVATAR_DECORATION(this.avatarDecorationData.asset), "png", size) : null;
+    }
+    /**
+     * The url of this user's avatar (or default avatar, if they have not set an avatar).
+     * @param format The format the url should be.
+     * @param size The dimensions of the image.
+     */
+    avatarURL(format, size) {
+        return this.avatar === null ? this.defaultAvatarURL() : this.client.util.formatImage(Routes.USER_AVATAR(this.id, this.avatar), format, size);
+    }
+    /**
+     * The url of this user's banner.
+     * @param format The format the url should be.
+     * @param size The dimensions of the image.
+     */
+    bannerURL(format, size) {
+        return this.banner ? this.client.util.formatImage(Routes.BANNER(this.id, this.banner), format, size) : null;
+    }
+    /**
+     * Create a direct message with this user.
+     */
+    async createDM() {
+        return this.client.rest.channels.createDM(this.id);
+    }
+    /**
+     * Create a test entitlement for this user.
+     * @param skuID The ID of the SKU to create an entitlement for.
+     * @param applicationID The ID of the application to create the entitlement for. If present, defaults to the logged in client's application id.
+     */
+    async createTestEntitlement(skuID, applicationID) {
+        if (applicationID === undefined && this.client["_application"] === undefined) {
+            throw new Errors_1.UncachedError("Client#application is not present, you must provide an applicationID as a second argument. To not need to provide an ID, only call this after at least one shard is READY, or restMode is enabled.");
+        }
+        return this.client.rest.applications.createTestEntitlement(applicationID ?? this.client.application.id, {
+            ownerID: this.id,
+            ownerType: Constants_1.EntitlementOwnerTypes.USER,
+            skuID
+        });
+    }
+    /**
+     * The url of this user's default avatar.
+     */
+    defaultAvatarURL() {
+        return this.client.util.formatImage(Routes.EMBED_AVATAR(this.defaultAvatar), "png");
+    }
+    /**
+     * Get the entitlements for this guild.
+     * @param options The options for getting the entitlements.
+     */
+    async getEntitlements(options, applicationID) {
+        if (applicationID === undefined && this.client["_application"] === undefined) {
+            throw new Errors_1.UncachedError("Client#application is not present, you must provide an applicationID as a second argument. To not need to provide an ID, only call this after at least one shard is READY, or restMode is enabled.");
+        }
+        return this.client.rest.applications.getEntitlements(applicationID ?? this.client.application.id, { userID: this.id, ...options });
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            accentColor: this.accentColor,
+            avatar: this.avatar,
+            avatarDecorationData: this.avatarDecorationData,
+            banner: this.banner,
+            bot: this.bot,
+            collectibles: this.collectibles,
+            discriminator: this.discriminator,
+            globalName: this.globalName,
+            publicFlags: this.publicFlags,
+            system: this.system,
+            username: this.username
+        };
+    }
+}
+exports.default = User;