baff.js 0.0.0-stage → 0.1.1

package/dist/cjs/structures/Message.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.MessageMentions = exports.MessageReaction = void 0;
+const InteractionCollector_js_1 = require("../collectors/InteractionCollector.js");
+const Collector_js_1 = require("../collectors/Collector.js");
+const Routes_js_1 = require("../rest/Routes.js");
+const Collection_js_1 = require("../util/Collection.js");
+const emoji_js_1 = require("../util/emoji.js");
+const constants_js_1 = require("../util/constants.js");
+const Base_js_1 = require("./Base.js");
+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_js_1.Routes.messageReaction(this.message.channelId, this.message.id, this.emoji));
+        return new Collection_js_1.Collection(list.map((u) => [u.id, this.message.client.users._add(u)]));
+    }
+    async remove() {
+        await this.message.client.rest.delete(Routes_js_1.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);
+    }
+}
+exports.MessageReaction = MessageReaction;
+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_js_1.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);
+    }
+}
+exports.MessageMentions = MessageMentions;
+class Message extends Base_js_1.Identified {
+    id;
+    channelId;
+    serverId;
+    author;
+    content = '';
+    editedAt = null;
+    type = 0;
+    attachments = new Collection_js_1.Collection();
+    embeds = [];
+    components = [];
+    flags = 0;
+    reactions = new Collection_js_1.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_js_1.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_js_1.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 & constants_js_1.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_js_1.Routes.messageReaction(this.channelId, this.id, (0, emoji_js_1.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_js_1.Routes.messageCrosspost(this.channelId, this.id));
+    }
+    async startThread(options) {
+        const data = await this.client.rest.post(Routes_js_1.Routes.channelThreads(this.channelId), { body: { ...options, messageId: this.id } });
+        return this.client.channels._addThread(data);
+    }
+    async endPoll() {
+        await this.client.rest.post(Routes_js_1.Routes.pollExpire(this.channelId, this.id));
+    }
+    async fetch() {
+        return (await this.channel.messages.fetch(this.id, { force: true }));
+    }
+    createMessageComponentCollector(options = {}) {
+        return new InteractionCollector_js_1.InteractionCollector(this.client, { ...options, messageId: this.id, channelId: this.channelId });
+    }
+    async awaitMessageComponent(options = {}) {
+        const collected = await (0, Collector_js_1.awaitCollector)(this.createMessageComponentCollector({ ...options, max: 1 }), ['time']);
+        return collected.first();
+    }
+    toString() {
+        return this.content;
+    }
+}
+exports.Message = Message;

package/dist/cjs/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/cjs/structures/Role.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+exports.roleEditBody = roleEditBody;
+const Routes_js_1 = require("../rest/Routes.js");
+const formatters_js_1 = require("../util/formatters.js");
+const Permissions_js_1 = require("../util/Permissions.js");
+const Base_js_1 = require("./Base.js");
+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(Permissions_js_1.PermissionsBitField.resolve(data.permissions));
+    return body;
+}
+class Role extends Base_js_1.Identified {
+    serverId;
+    id;
+    name = '';
+    color = 0;
+    hoist = false;
+    position = 0;
+    permissions = new Permissions_js_1.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 = Permissions_js_1.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_js_1.Routes.serverRole(this.serverId, this.id), { body: roleEditBody(data) });
+        return this._patch(updated);
+    }
+    async delete() {
+        await this.client.rest.delete(Routes_js_1.Routes.serverRole(this.serverId, this.id));
+        this.server?.roles.cache.delete(this.id);
+    }
+    toString() {
+        return (0, formatters_js_1.roleMention)(this.id);
+    }
+}
+exports.Role = Role;

package/dist/cjs/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>;
+}

package/dist/cjs/structures/ScheduledEvent.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledEvent = void 0;
+exports.eventBody = eventBody;
+const Routes_js_1 = require("../rest/Routes.js");
+const Base_js_1 = require("./Base.js");
+function eventBody(data) {
+    const iso = (value) => (value instanceof Date ? value.toISOString() : value);
+    return { ...data, startAt: iso(data.startAt), endAt: iso(data.endAt) };
+}
+class ScheduledEvent extends Base_js_1.Identified {
+    id;
+    serverId;
+    creatorId = null;
+    name = '';
+    description = '';
+    locationKind = 'voice';
+    channelId = null;
+    location = null;
+    startAt = new Date(0);
+    endAt = null;
+    coverUrl = null;
+    status = 'scheduled';
+    interestedCount = 0;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.serverId = data.serverId;
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.creatorId !== undefined)
+            this.creatorId = data.creatorId;
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.description !== undefined)
+            this.description = data.description;
+        if (data.locationKind !== undefined)
+            this.locationKind = data.locationKind;
+        if (data.channelId !== undefined)
+            this.channelId = data.channelId;
+        if (data.location !== undefined)
+            this.location = data.location;
+        if (data.startAt !== undefined)
+            this.startAt = new Date(data.startAt);
+        if (data.endAt !== undefined)
+            this.endAt = data.endAt ? new Date(data.endAt) : null;
+        if (data.coverUrl !== undefined)
+            this.coverUrl = data.coverUrl;
+        if (data.status !== undefined)
+            this.status = data.status;
+        if (data.interestedCount !== undefined)
+            this.interestedCount = data.interestedCount;
+        return this;
+    }
+    async edit(data) {
+        const updated = await this.client.rest.patch(Routes_js_1.Routes.serverEvent(this.serverId, this.id), { body: eventBody(data) });
+        return this._patch(updated);
+    }
+    start() {
+        return this.edit({ status: 'active' });
+    }
+    end() {
+        return this.edit({ status: 'completed' });
+    }
+    cancel() {
+        return this.edit({ status: 'canceled' });
+    }
+    async delete() {
+        await this.client.rest.delete(Routes_js_1.Routes.serverEvent(this.serverId, this.id));
+    }
+}
+exports.ScheduledEvent = ScheduledEvent;

package/dist/cjs/structures/Server.d.ts

@@ -0,0 +1,68 @@
+import type { Client } from '../client/Client.js';
+import { ApplicationCommandManager } from '../managers/CommandManager.js';
+import { EventManager } from '../managers/EventManager.js';
+import { EmojiManager, StickerManager } from '../managers/ExpressionManagers.js';
+import { InviteManager } from '../managers/InviteManager.js';
+import { MemberManager } from '../managers/MemberManager.js';
+import { RoleManager } from '../managers/RoleManager.js';
+import { ServerChannelManager } from '../managers/ServerChannelManager.js';
+import type { APIAuditEntry, APIServer, APIServerSummary, APIVoiceState } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { Identified } from './Base.js';
+import type { ServerMember } from './ServerMember.js';
+import type { User } from './User.js';
+export interface ServerEditData {
+    name?: string;
+    systemChannelId?: string | null;
+    systemFlags?: number;
+    defaultNotifications?: 'all' | 'mentions';
+}
+export interface AuditLogEntry extends Omit<APIAuditEntry, 'actorId' | 'createdAt'> {
+    actorId: string | null;
+    actor: User | null;
+    createdAt: Date;
+}
+export interface AuditLogQuery {
+    limit?: number;
+    before?: string;
+    userId?: string;
+    action?: string;
+}
+export declare class Server extends Identified {
+    readonly id: string;
+    name: string;
+    iconUrl: string | null;
+    bannerUrl: string | null;
+    ownerId: string;
+    types: string[];
+    community: boolean;
+    listed: boolean;
+    invitesPaused: boolean;
+    systemChannelId: string | null;
+    boostCount: number;
+    boostTier: number;
+    myRoleIds: string[];
+    detailed: boolean;
+    readonly channels: ServerChannelManager;
+    readonly roles: RoleManager;
+    readonly members: MemberManager;
+    readonly emojis: EmojiManager;
+    readonly stickers: StickerManager;
+    readonly invites: InviteManager;
+    readonly events: EventManager;
+    readonly commands: ApplicationCommandManager;
+    readonly voiceStates: Collection<string, APIVoiceState>;
+    constructor(client: Client, data: APIServerSummary | APIServer);
+    _patch(data: Partial<APIServer>): this;
+    _applyDetail(data: APIServer): void;
+    get me(): ServerMember | null;
+    get url(): string;
+    get systemChannel(): import("./channels/ServerChannels.js").ServerChannel | null;
+    fetch(): Promise<Server>;
+    edit(data: ServerEditData): Promise<Server>;
+    setName(name: string): Promise<Server>;
+    leave(): Promise<void>;
+    fetchAuditLog(query?: AuditLogQuery): Promise<Collection<string, AuditLogEntry>>;
+    fetchVoiceStates(): Promise<Collection<string, APIVoiceState>>;
+    toString(): string;
+}

package/dist/cjs/structures/Server.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const CommandManager_js_1 = require("../managers/CommandManager.js");
+const EventManager_js_1 = require("../managers/EventManager.js");
+const ExpressionManagers_js_1 = require("../managers/ExpressionManagers.js");
+const InviteManager_js_1 = require("../managers/InviteManager.js");
+const MemberManager_js_1 = require("../managers/MemberManager.js");
+const RoleManager_js_1 = require("../managers/RoleManager.js");
+const ServerChannelManager_js_1 = require("../managers/ServerChannelManager.js");
+const Routes_js_1 = require("../rest/Routes.js");
+const Collection_js_1 = require("../util/Collection.js");
+const Base_js_1 = require("./Base.js");
+class Server extends Base_js_1.Identified {
+    id;
+    name;
+    iconUrl = null;
+    bannerUrl = null;
+    ownerId = '';
+    types = [];
+    community = false;
+    listed = false;
+    invitesPaused = false;
+    systemChannelId = null;
+    boostCount = 0;
+    boostTier = 0;
+    myRoleIds = [];
+    detailed = false;
+    channels;
+    roles;
+    members;
+    emojis;
+    stickers;
+    invites;
+    events;
+    commands;
+    voiceStates = new Collection_js_1.Collection();
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.name = data.name;
+        this.channels = new ServerChannelManager_js_1.ServerChannelManager(client, data.id);
+        this.roles = new RoleManager_js_1.RoleManager(client, data.id);
+        this.members = new MemberManager_js_1.MemberManager(client, data.id);
+        this.emojis = new ExpressionManagers_js_1.EmojiManager(client, data.id);
+        this.stickers = new ExpressionManagers_js_1.StickerManager(client, data.id);
+        this.invites = new InviteManager_js_1.InviteManager(client, data.id);
+        this.events = new EventManager_js_1.EventManager(client, data.id);
+        this.commands = new CommandManager_js_1.ApplicationCommandManager(client, () => client.requireApplicationId(), data.id);
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.iconUrl !== undefined)
+            this.iconUrl = data.iconUrl;
+        if (data.bannerUrl !== undefined)
+            this.bannerUrl = data.bannerUrl;
+        if (data.ownerId !== undefined)
+            this.ownerId = data.ownerId;
+        if (data.types !== undefined)
+            this.types = data.types;
+        if (data.community !== undefined)
+            this.community = data.community;
+        if (data.listed !== undefined)
+            this.listed = data.listed;
+        if (data.invitesPaused !== undefined)
+            this.invitesPaused = data.invitesPaused;
+        if (data.systemChannelId !== undefined)
+            this.systemChannelId = data.systemChannelId;
+        if (data.boostCount !== undefined)
+            this.boostCount = data.boostCount;
+        if (data.boostTier !== undefined)
+            this.boostTier = data.boostTier;
+        if (data.myRoles !== undefined)
+            this.myRoleIds = data.myRoles;
+        return this;
+    }
+    _applyDetail(data) {
+        this.detailed = true;
+        this.roles._setAll(data.roles);
+        this.client.channels._replaceServer(this.id, data.channels);
+    }
+    get me() {
+        return this.members.me;
+    }
+    get url() {
+        return `${this.client.appUrl}/channels/${this.id}`;
+    }
+    get systemChannel() {
+        return this.systemChannelId ? (this.channels.cache.get(this.systemChannelId) ?? null) : null;
+    }
+    fetch() {
+        return this.client.servers.fetch(this.id, { force: true });
+    }
+    async edit(data) {
+        await this.client.rest.patch(Routes_js_1.Routes.serverSettings(this.id), { body: data });
+        return this._patch(data);
+    }
+    setName(name) {
+        return this.edit({ name });
+    }
+    leave() {
+        return this.client.servers.leave(this.id);
+    }
+    async fetchAuditLog(query = {}) {
+        const res = await this.client.rest.get(Routes_js_1.Routes.auditLog(this.id), { query: { ...query } });
+        for (const u of res.users)
+            this.client.users._add(u);
+        return new Collection_js_1.Collection(res.entries.map((e) => [e.id, { ...e, actor: e.actorId ? (this.client.users.cache.get(e.actorId) ?? null) : null, createdAt: new Date(e.createdAt) }]));
+    }
+    async fetchVoiceStates() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.voiceStates(this.id));
+        this.voiceStates.clear();
+        for (const state of list)
+            if (state.channelId)
+                this.voiceStates.set(state.userId, state);
+        return this.voiceStates;
+    }
+    toString() {
+        return this.name;
+    }
+}
+exports.Server = Server;

package/dist/cjs/structures/ServerAssets.d.ts

@@ -0,0 +1,48 @@
+import type { Client } from '../client/Client.js';
+import type { APIEmoji, APIInvite, APISticker } from '../types.js';
+import { Base, Identified } from './Base.js';
+export declare class Emoji extends Identified {
+    readonly id: string;
+    readonly serverId: string;
+    name: string;
+    animated: boolean;
+    url: string;
+    uploader: string | null;
+    constructor(client: Client, data: APIEmoji);
+    get identifier(): string;
+    setName(name: string): Promise<Emoji>;
+    delete(): Promise<void>;
+    toString(): string;
+}
+export declare class Sticker extends Identified {
+    readonly id: string;
+    readonly serverId: string | null;
+    name: string;
+    description: string;
+    emoji: string | null;
+    animated: boolean;
+    url: string | null;
+    constructor(client: Client, data: APISticker, serverId?: string);
+    edit(data: {
+        name?: string;
+        description?: string;
+        emoji?: string;
+    }): Promise<Sticker>;
+    delete(): Promise<void>;
+}
+export declare class Invite extends Base {
+    readonly serverId: string | null;
+    readonly code: string;
+    maxAgeSecs: number | null;
+    maxUses: number | null;
+    uses: number;
+    temporary: boolean;
+    expiresAt: Date | null;
+    inviterId: string | null;
+    vanity: boolean;
+    server: APIInvite['server'];
+    constructor(client: Client, data: APIInvite, serverId?: string | null);
+    get url(): string;
+    delete(): Promise<void>;
+    toString(): string;
+}