baff.js 0.0.0-stage → 0.1.0

package/dist/esm/rest/Routes.d.ts

@@ -0,0 +1,54 @@
+export declare const Routes: {
+    me: () => "/auth/me";
+    presence: () => "/users/@me/presence";
+    userTags: () => "/users/tags";
+    userProfile: (userId: string) => `/users/${string}/profile`;
+    dms: () => "/users/@me/channels";
+    servers: () => "/servers";
+    server: (serverId: string) => `/servers/${string}`;
+    serverLeave: (serverId: string) => `/users/@me/servers/${string}`;
+    serverSettings: (serverId: string) => `/servers/${string}/settings`;
+    serverChannels: (serverId: string) => `/servers/${string}/channels`;
+    serverMembers: (serverId: string) => `/servers/${string}/members`;
+    serverMember: (serverId: string, userId: string) => `/servers/${string}/members/${string}`;
+    memberRole: (serverId: string, userId: string, roleId: string) => `/servers/${string}/members/${string}/roles/${string}`;
+    memberTimeout: (serverId: string, userId: string) => `/servers/${string}/members/${string}/timeout`;
+    serverBans: (serverId: string) => `/servers/${string}/bans`;
+    serverBan: (serverId: string, userId: string) => `/servers/${string}/bans/${string}`;
+    serverRoles: (serverId: string) => `/servers/${string}/roles`;
+    serverRole: (serverId: string, roleId: string) => `/servers/${string}/roles/${string}`;
+    serverInvites: (serverId: string) => `/servers/${string}/invites`;
+    serverInvite: (serverId: string, code: string) => `/servers/${string}/invites/${string}`;
+    serverEmojis: (serverId: string) => `/servers/${string}/emojis`;
+    serverEmoji: (serverId: string, emojiId: string) => `/servers/${string}/emojis/${string}`;
+    serverStickers: (serverId: string) => `/servers/${string}/stickers`;
+    serverSticker: (serverId: string, stickerId: string) => `/servers/${string}/stickers/${string}`;
+    serverEvents: (serverId: string) => `/servers/${string}/events`;
+    serverEvent: (serverId: string, eventId: string) => `/servers/${string}/events/${string}`;
+    auditLog: (serverId: string) => `/servers/${string}/audit-log`;
+    voiceStates: (serverId: string) => `/servers/${string}/voice-states`;
+    invite: (code: string) => `/invites/${string}`;
+    channel: (channelId: string) => `/channels/${string}`;
+    channelMessages: (channelId: string) => `/channels/${string}/messages`;
+    channelMessage: (channelId: string, messageId: string) => `/channels/${string}/messages/${string}`;
+    messageReaction: (channelId: string, messageId: string, emoji: string) => `/channels/${string}/messages/${string}/reactions/${string}`;
+    messageCrosspost: (channelId: string, messageId: string) => `/channels/${string}/messages/${string}/crosspost`;
+    channelPins: (channelId: string) => `/channels/${string}/pins`;
+    channelPin: (channelId: string, messageId: string) => `/channels/${string}/pins/${string}`;
+    channelTyping: (channelId: string) => `/channels/${string}/typing`;
+    channelThreads: (channelId: string) => `/channels/${string}/threads`;
+    channelPosts: (channelId: string) => `/channels/${string}/posts`;
+    channelWebhooks: (channelId: string) => `/channels/${string}/webhooks`;
+    channelVoice: (channelId: string) => `/channels/${string}/voice`;
+    channelVoiceStatus: (channelId: string) => `/channels/${string}/voice-status`;
+    pollExpire: (channelId: string, messageId: string) => `/channels/${string}/polls/${string}/expire`;
+    voice: () => "/voice";
+    webhook: (webhookId: string) => `/webhooks/${string}`;
+    webhookExecute: (webhookId: string, token: string) => `/webhooks/${string}/${string}`;
+    applicationCommands: (applicationId: string) => `/applications/${string}/commands`;
+    applicationCommand: (applicationId: string, commandId: string) => `/applications/${string}/commands/${string}`;
+    serverCommands: (applicationId: string, serverId: string) => `/applications/${string}/servers/${string}/commands`;
+    interactionCallback: (id: string, token: string) => `/interactions/${string}/${string}/callback`;
+    interactionFollowup: (id: string, token: string) => `/interactions/${string}/${string}/followup`;
+    interactionOriginal: (id: string, token: string) => `/interactions/${string}/${string}/original`;
+};

package/dist/esm/rest/Routes.js

@@ -0,0 +1,55 @@
+const e = encodeURIComponent;
+export const Routes = {
+    me: () => '/auth/me',
+    presence: () => '/users/@me/presence',
+    userTags: () => '/users/tags',
+    userProfile: (userId) => `/users/${userId}/profile`,
+    dms: () => '/users/@me/channels',
+    servers: () => '/servers',
+    server: (serverId) => `/servers/${serverId}`,
+    serverLeave: (serverId) => `/users/@me/servers/${serverId}`,
+    serverSettings: (serverId) => `/servers/${serverId}/settings`,
+    serverChannels: (serverId) => `/servers/${serverId}/channels`,
+    serverMembers: (serverId) => `/servers/${serverId}/members`,
+    serverMember: (serverId, userId) => `/servers/${serverId}/members/${userId}`,
+    memberRole: (serverId, userId, roleId) => `/servers/${serverId}/members/${userId}/roles/${roleId}`,
+    memberTimeout: (serverId, userId) => `/servers/${serverId}/members/${userId}/timeout`,
+    serverBans: (serverId) => `/servers/${serverId}/bans`,
+    serverBan: (serverId, userId) => `/servers/${serverId}/bans/${userId}`,
+    serverRoles: (serverId) => `/servers/${serverId}/roles`,
+    serverRole: (serverId, roleId) => `/servers/${serverId}/roles/${roleId}`,
+    serverInvites: (serverId) => `/servers/${serverId}/invites`,
+    serverInvite: (serverId, code) => `/servers/${serverId}/invites/${e(code)}`,
+    serverEmojis: (serverId) => `/servers/${serverId}/emojis`,
+    serverEmoji: (serverId, emojiId) => `/servers/${serverId}/emojis/${emojiId}`,
+    serverStickers: (serverId) => `/servers/${serverId}/stickers`,
+    serverSticker: (serverId, stickerId) => `/servers/${serverId}/stickers/${stickerId}`,
+    serverEvents: (serverId) => `/servers/${serverId}/events`,
+    serverEvent: (serverId, eventId) => `/servers/${serverId}/events/${eventId}`,
+    auditLog: (serverId) => `/servers/${serverId}/audit-log`,
+    voiceStates: (serverId) => `/servers/${serverId}/voice-states`,
+    invite: (code) => `/invites/${e(code)}`,
+    channel: (channelId) => `/channels/${channelId}`,
+    channelMessages: (channelId) => `/channels/${channelId}/messages`,
+    channelMessage: (channelId, messageId) => `/channels/${channelId}/messages/${messageId}`,
+    messageReaction: (channelId, messageId, emoji) => `/channels/${channelId}/messages/${messageId}/reactions/${e(emoji)}`,
+    messageCrosspost: (channelId, messageId) => `/channels/${channelId}/messages/${messageId}/crosspost`,
+    channelPins: (channelId) => `/channels/${channelId}/pins`,
+    channelPin: (channelId, messageId) => `/channels/${channelId}/pins/${messageId}`,
+    channelTyping: (channelId) => `/channels/${channelId}/typing`,
+    channelThreads: (channelId) => `/channels/${channelId}/threads`,
+    channelPosts: (channelId) => `/channels/${channelId}/posts`,
+    channelWebhooks: (channelId) => `/channels/${channelId}/webhooks`,
+    channelVoice: (channelId) => `/channels/${channelId}/voice`,
+    channelVoiceStatus: (channelId) => `/channels/${channelId}/voice-status`,
+    pollExpire: (channelId, messageId) => `/channels/${channelId}/polls/${messageId}/expire`,
+    voice: () => '/voice',
+    webhook: (webhookId) => `/webhooks/${webhookId}`,
+    webhookExecute: (webhookId, token) => `/webhooks/${webhookId}/${e(token)}`,
+    applicationCommands: (applicationId) => `/applications/${applicationId}/commands`,
+    applicationCommand: (applicationId, commandId) => `/applications/${applicationId}/commands/${commandId}`,
+    serverCommands: (applicationId, serverId) => `/applications/${applicationId}/servers/${serverId}/commands`,
+    interactionCallback: (id, token) => `/interactions/${id}/${e(token)}/callback`,
+    interactionFollowup: (id, token) => `/interactions/${id}/${e(token)}/followup`,
+    interactionOriginal: (id, token) => `/interactions/${id}/${e(token)}/original`
+};

package/dist/esm/rest/files.d.ts

@@ -0,0 +1,19 @@
+export type FileData = Uint8Array | ArrayBuffer | Blob | string;
+export interface RawFile {
+    name: string;
+    data: FileData;
+    contentType?: string;
+}
+export declare class AttachmentBuilder {
+    readonly data: FileData;
+    name: string;
+    contentType?: string;
+    constructor(data: FileData, options?: {
+        name?: string;
+        contentType?: string;
+    });
+    setName(name: string): this;
+    toFile(): RawFile;
+}
+export declare function toBlob(file: RawFile): Blob;
+export declare function buildForm(payload: unknown, files: readonly RawFile[]): FormData;

package/dist/esm/rest/files.js

@@ -0,0 +1,31 @@
+export class AttachmentBuilder {
+    data;
+    name;
+    contentType;
+    constructor(data, options = {}) {
+        this.data = data;
+        this.name = options.name ?? 'file';
+        this.contentType = options.contentType;
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    toFile() {
+        return { name: this.name, data: this.data, contentType: this.contentType };
+    }
+}
+export function toBlob(file) {
+    if (file.data instanceof Blob)
+        return file.data;
+    const type = file.contentType ?? 'application/octet-stream';
+    const part = file.data instanceof ArrayBuffer || typeof file.data === 'string' ? file.data : new Uint8Array(file.data);
+    return new Blob([part], { type });
+}
+export function buildForm(payload, files) {
+    const form = new FormData();
+    form.append('payload_json', JSON.stringify(payload));
+    for (const file of files)
+        form.append('files', toBlob(file), file.name);
+    return form;
+}

package/dist/esm/structures/Base.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from '../client/Client.js';
+export declare abstract class Base {
+    readonly client: Client;
+    constructor(client: Client);
+    _clone(): this;
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+export declare abstract class Identified extends Base {
+    abstract readonly id: string;
+    get createdTimestamp(): number;
+    get createdAt(): Date;
+}

package/dist/esm/structures/Base.js

@@ -0,0 +1,25 @@
+import { Snowflake } from '../util/Snowflake.js';
+export class Base {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    _clone() {
+        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    }
+    toString() {
+        return `${this.constructor.name}`;
+    }
+    toJSON() {
+        const { client: _client, ...rest } = this;
+        return rest;
+    }
+}
+export class Identified extends Base {
+    get createdTimestamp() {
+        return Snowflake.timestampOf(this.id);
+    }
+    get createdAt() {
+        return new Date(this.createdTimestamp);
+    }
+}

package/dist/esm/structures/Message.d.ts

@@ -0,0 +1,91 @@
+import type { Client } from '../client/Client.js';
+import type { MessageOptions } from '../builders/messagePayload.js';
+import { InteractionCollector, type InteractionCollectorOptions } from '../collectors/InteractionCollector.js';
+import type { APIAttachment, APIComponent, APIEmbed, APIMessage, APISticker, APIUser } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { type EmojiResolvable } from '../util/emoji.js';
+import { Identified } from './Base.js';
+import type { MessageComponentInteraction } from './interactions/ComponentInteraction.js';
+import type { TextBasedChannel } from './channels/TextBasedChannel.js';
+import type { ThreadChannel } from './channels/ServerChannels.js';
+import type { Server } from './Server.js';
+import type { ServerMember } from './ServerMember.js';
+import { User } from './User.js';
+export declare class MessageReaction {
+    readonly message: Message;
+    readonly emoji: string;
+    count: number;
+    me: boolean;
+    constructor(message: Message, emoji: string, count: number, me: boolean);
+    fetchUsers(): Promise<Collection<string, User>>;
+    remove(): Promise<void>;
+}
+export declare class MessageMentions {
+    private readonly message;
+    readonly userIds: string[];
+    readonly roleIds: string[];
+    readonly everyone: boolean;
+    constructor(message: Message, userIds: string[], roleIds: string[], everyone: boolean);
+    get users(): Collection<string, User>;
+    has(target: string | {
+        id: string;
+    }, options?: {
+        ignoreEveryone?: boolean;
+    }): boolean;
+}
+export declare class Message extends Identified {
+    readonly id: string;
+    readonly channelId: string;
+    serverId: string | null;
+    author: User;
+    content: string;
+    editedAt: Date | null;
+    type: number;
+    attachments: Collection<string, APIAttachment>;
+    embeds: APIEmbed[];
+    components: APIComponent[];
+    flags: number;
+    reactions: Collection<string, MessageReaction>;
+    mentions: MessageMentions;
+    reference: {
+        id: string;
+        author: APIUser;
+        content: string;
+    } | null;
+    replyDeleted: boolean;
+    pinned: boolean;
+    crossposted: boolean;
+    stickers: APISticker[];
+    poll: unknown;
+    forward: unknown;
+    interaction: {
+        user: APIUser;
+        name: string;
+    } | null;
+    nonce: string | null;
+    constructor(client: Client, data: APIMessage);
+    _patch(data: Partial<APIMessage>): this;
+    get channel(): TextBasedChannel;
+    get server(): Server | null;
+    get member(): ServerMember | null;
+    get url(): string;
+    get editable(): boolean;
+    get isComponentsV2(): boolean;
+    reply(options: string | MessageOptions): Promise<Message>;
+    edit(options: string | MessageOptions): Promise<Message>;
+    delete(): Promise<void>;
+    react(emoji: EmojiResolvable): Promise<void>;
+    unreact(emoji: EmojiResolvable): Promise<void>;
+    pin(): Promise<void>;
+    unpin(): Promise<void>;
+    crosspost(): Promise<void>;
+    startThread(options: {
+        name: string;
+        autoArchiveMinutes?: number;
+    }): Promise<ThreadChannel>;
+    endPoll(): Promise<void>;
+    fetch(): Promise<Message>;
+    createMessageComponentCollector(options?: InteractionCollectorOptions): InteractionCollector;
+    awaitMessageComponent(options?: InteractionCollectorOptions): Promise<MessageComponentInteraction>;
+    toString(): string;
+}

package/dist/esm/structures/Message.js

@@ -0,0 +1,194 @@
+import { InteractionCollector } from '../collectors/InteractionCollector.js';
+import { awaitCollector } from '../collectors/Collector.js';
+import { Routes } from '../rest/Routes.js';
+import { Collection } from '../util/Collection.js';
+import { resolveEmoji } from '../util/emoji.js';
+import { MessageFlags } from '../util/constants.js';
+import { Identified } from './Base.js';
+export class MessageReaction {
+    message;
+    emoji;
+    count;
+    me;
+    constructor(message, emoji, count, me) {
+        this.message = message;
+        this.emoji = emoji;
+        this.count = count;
+        this.me = me;
+    }
+    async fetchUsers() {
+        const list = await this.message.client.rest.get(Routes.messageReaction(this.message.channelId, this.message.id, this.emoji));
+        return new Collection(list.map((u) => [u.id, this.message.client.users._add(u)]));
+    }
+    async remove() {
+        await this.message.client.rest.delete(Routes.messageReaction(this.message.channelId, this.message.id, this.emoji));
+        this.me = false;
+        this.count = Math.max(0, this.count - 1);
+        if (this.count === 0)
+            this.message.reactions.delete(this.emoji);
+    }
+}
+export class MessageMentions {
+    message;
+    userIds;
+    roleIds;
+    everyone;
+    constructor(message, userIds, roleIds, everyone) {
+        this.message = message;
+        this.userIds = userIds;
+        this.roleIds = roleIds;
+        this.everyone = everyone;
+    }
+    get users() {
+        const out = new Collection();
+        for (const id of this.userIds) {
+            const user = this.message.client.users.cache.get(id);
+            if (user)
+                out.set(id, user);
+        }
+        return out;
+    }
+    has(target, options = {}) {
+        const id = typeof target === 'string' ? target : target.id;
+        return this.userIds.includes(id) || this.roleIds.includes(id) || (!options.ignoreEveryone && this.everyone);
+    }
+}
+export class Message extends Identified {
+    id;
+    channelId;
+    serverId;
+    author;
+    content = '';
+    editedAt = null;
+    type = 0;
+    attachments = new Collection();
+    embeds = [];
+    components = [];
+    flags = 0;
+    reactions = new Collection();
+    mentions = new MessageMentions(this, [], [], false);
+    reference = null;
+    replyDeleted = false;
+    pinned = false;
+    crossposted = false;
+    stickers = [];
+    poll = null;
+    forward = null;
+    interaction = null;
+    nonce = null;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.channelId = data.channelId;
+        this.serverId = data.serverId ?? null;
+        this.author = client.users._add(data.author);
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.serverId !== undefined)
+            this.serverId = data.serverId;
+        if (data.author)
+            this.author = this.client.users._add(data.author);
+        if (data.content !== undefined)
+            this.content = data.content;
+        if (data.editedAt !== undefined)
+            this.editedAt = data.editedAt ? new Date(data.editedAt) : null;
+        if (data.type !== undefined)
+            this.type = data.type;
+        if (data.attachments)
+            this.attachments = new Collection(data.attachments.map((a) => [a.id, a]));
+        if (data.embeds)
+            this.embeds = data.embeds;
+        if (data.components)
+            this.components = data.components;
+        if (data.flags !== undefined)
+            this.flags = data.flags;
+        if (data.reactions)
+            this.reactions = new Collection(data.reactions.map((r) => [r.emoji, new MessageReaction(this, r.emoji, r.count, r.me)]));
+        if (data.mentions || data.mentionRoles || data.mentionEveryone !== undefined) {
+            this.mentions = new MessageMentions(this, data.mentions ?? this.mentions.userIds, data.mentionRoles ?? this.mentions.roleIds, data.mentionEveryone ?? this.mentions.everyone);
+        }
+        if (data.reply !== undefined)
+            this.reference = data.reply ? { id: data.reply.id, author: data.reply.author, content: data.reply.content } : null;
+        if (data.replyDeleted !== undefined)
+            this.replyDeleted = data.replyDeleted;
+        if (data.pinned !== undefined)
+            this.pinned = data.pinned;
+        if (data.crossposted !== undefined)
+            this.crossposted = data.crossposted;
+        if (data.stickers)
+            this.stickers = data.stickers;
+        if (data.poll !== undefined)
+            this.poll = data.poll;
+        if (data.forward !== undefined)
+            this.forward = data.forward;
+        if (data.interaction !== undefined)
+            this.interaction = data.interaction;
+        if (data.nonce !== undefined)
+            this.nonce = data.nonce;
+        return this;
+    }
+    get channel() {
+        return this.client.channels._textChannel(this.channelId, this.serverId);
+    }
+    get server() {
+        return this.serverId ? (this.client.servers.cache.get(this.serverId) ?? null) : null;
+    }
+    get member() {
+        return this.server?.members.cache.get(this.author.id) ?? null;
+    }
+    get url() {
+        return `${this.channel.url}?message=${this.id}`;
+    }
+    get editable() {
+        return this.author.id === this.client.user?.id;
+    }
+    get isComponentsV2() {
+        return (this.flags & MessageFlags.IsComponentsV2) !== 0;
+    }
+    reply(options) {
+        const body = typeof options === 'string' ? { content: options } : options;
+        return this.channel.send({ ...body, replyTo: this.id });
+    }
+    edit(options) {
+        return this.channel.messages.edit(this.id, options);
+    }
+    delete() {
+        return this.channel.messages.delete(this.id);
+    }
+    react(emoji) {
+        return this.channel.messages.react(this.id, emoji);
+    }
+    async unreact(emoji) {
+        await this.client.rest.delete(Routes.messageReaction(this.channelId, this.id, resolveEmoji(emoji)));
+    }
+    pin() {
+        return this.channel.messages.pin(this.id);
+    }
+    unpin() {
+        return this.channel.messages.unpin(this.id);
+    }
+    async crosspost() {
+        await this.client.rest.post(Routes.messageCrosspost(this.channelId, this.id));
+    }
+    async startThread(options) {
+        const data = await this.client.rest.post(Routes.channelThreads(this.channelId), { body: { ...options, messageId: this.id } });
+        return this.client.channels._addThread(data);
+    }
+    async endPoll() {
+        await this.client.rest.post(Routes.pollExpire(this.channelId, this.id));
+    }
+    async fetch() {
+        return (await this.channel.messages.fetch(this.id, { force: true }));
+    }
+    createMessageComponentCollector(options = {}) {
+        return new InteractionCollector(this.client, { ...options, messageId: this.id, channelId: this.channelId });
+    }
+    async awaitMessageComponent(options = {}) {
+        const collected = await awaitCollector(this.createMessageComponentCollector({ ...options, max: 1 }), ['time']);
+        return collected.first();
+    }
+    toString() {
+        return this.content;
+    }
+}

package/dist/esm/structures/Role.d.ts

@@ -0,0 +1,34 @@
+import type { Client } from '../client/Client.js';
+import type { APIRole } from '../types.js';
+import { PermissionsBitField, type PermissionResolvable } from '../util/Permissions.js';
+import { Identified } from './Base.js';
+import type { Server } from './Server.js';
+export interface RoleEditData {
+    name?: string;
+    color?: number | `#${string}` | null;
+    hoist?: boolean;
+    permissions?: PermissionResolvable;
+}
+export declare function roleEditBody(data: RoleEditData): Record<string, unknown>;
+export declare class Role extends Identified {
+    readonly serverId: string;
+    readonly id: string;
+    name: string;
+    color: number;
+    hoist: boolean;
+    position: number;
+    permissions: PermissionsBitField;
+    icon: string | null;
+    botId: string | null;
+    booster: boolean;
+    constructor(client: Client, serverId: string, data: APIRole);
+    _patch(data: Partial<APIRole>): this;
+    get hexColor(): string;
+    get managed(): boolean;
+    get isEveryone(): boolean;
+    get server(): Server | null;
+    comparePositionTo(other: Role): number;
+    edit(data: RoleEditData): Promise<Role>;
+    delete(): Promise<void>;
+    toString(): string;
+}

package/dist/esm/structures/Role.js

@@ -0,0 +1,79 @@
+import { Routes } from '../rest/Routes.js';
+import { roleMention } from '../util/formatters.js';
+import { PermissionsBitField } from '../util/Permissions.js';
+import { Identified } from './Base.js';
+export function roleEditBody(data) {
+    const body = {};
+    if (data.name !== undefined)
+        body.name = data.name;
+    if (data.color !== undefined)
+        body.color = data.color === null ? null : typeof data.color === 'number' ? `#${data.color.toString(16).padStart(6, '0')}` : data.color;
+    if (data.hoist !== undefined)
+        body.hoist = data.hoist;
+    if (data.permissions !== undefined)
+        body.permissions = Number(PermissionsBitField.resolve(data.permissions));
+    return body;
+}
+export class Role extends Identified {
+    serverId;
+    id;
+    name = '';
+    color = 0;
+    hoist = false;
+    position = 0;
+    permissions = new PermissionsBitField();
+    icon = null;
+    botId = null;
+    booster = false;
+    constructor(client, serverId, data) {
+        super(client);
+        this.serverId = serverId;
+        this.id = data.id;
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.color !== undefined)
+            this.color = data.color ? parseInt(data.color.slice(1), 16) : 0;
+        if (data.hoist !== undefined)
+            this.hoist = data.hoist;
+        if (data.position !== undefined)
+            this.position = data.position;
+        if (data.permissions !== undefined)
+            this.permissions = PermissionsBitField.fromBits(data.permissions);
+        if (data.icon !== undefined)
+            this.icon = data.icon ?? null;
+        if (data.botId !== undefined)
+            this.botId = data.botId ?? null;
+        if (data.booster !== undefined)
+            this.booster = data.booster;
+        return this;
+    }
+    get hexColor() {
+        return `#${this.color.toString(16).padStart(6, '0')}`;
+    }
+    get managed() {
+        return this.botId !== null || this.booster;
+    }
+    get isEveryone() {
+        return this.id === this.serverId;
+    }
+    get server() {
+        return this.client.servers.cache.get(this.serverId) ?? null;
+    }
+    comparePositionTo(other) {
+        return this.position - other.position;
+    }
+    async edit(data) {
+        const updated = await this.client.rest.patch(Routes.serverRole(this.serverId, this.id), { body: roleEditBody(data) });
+        return this._patch(updated);
+    }
+    async delete() {
+        await this.client.rest.delete(Routes.serverRole(this.serverId, this.id));
+        this.server?.roles.cache.delete(this.id);
+    }
+    toString() {
+        return roleMention(this.id);
+    }
+}

package/dist/esm/structures/ScheduledEvent.d.ts

@@ -0,0 +1,37 @@
+import type { Client } from '../client/Client.js';
+import type { APIServerEvent } from '../types.js';
+import { Identified } from './Base.js';
+export interface ScheduledEventData {
+    name?: string;
+    description?: string;
+    locationKind?: 'voice' | 'external';
+    channelId?: string | null;
+    location?: string | null;
+    startAt?: Date | string;
+    endAt?: Date | string | null;
+}
+export declare function eventBody(data: ScheduledEventData): Record<string, unknown>;
+export declare class ScheduledEvent extends Identified {
+    readonly id: string;
+    readonly serverId: string;
+    creatorId: string | null;
+    name: string;
+    description: string;
+    locationKind: 'voice' | 'external';
+    channelId: string | null;
+    location: string | null;
+    startAt: Date;
+    endAt: Date | null;
+    coverUrl: string | null;
+    status: APIServerEvent['status'];
+    interestedCount: number;
+    constructor(client: Client, data: APIServerEvent);
+    _patch(data: Partial<APIServerEvent>): this;
+    edit(data: ScheduledEventData & {
+        status?: 'active' | 'completed' | 'canceled';
+    }): Promise<ScheduledEvent>;
+    start(): Promise<ScheduledEvent>;
+    end(): Promise<ScheduledEvent>;
+    cancel(): Promise<ScheduledEvent>;
+    delete(): Promise<void>;
+}