baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/managers/InviteManager.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+const ServerAssets_js_1 = require("../structures/ServerAssets.js");
+const Collection_js_1 = require("../util/Collection.js");
+class InviteManager {
+    client;
+    serverId;
+    constructor(client, serverId) {
+        this.client = client;
+        this.serverId = serverId;
+    }
+    async create(options = {}) {
+        const data = await this.client.rest.post(Routes_js_1.Routes.serverInvites(this.serverId), { body: options });
+        return new ServerAssets_js_1.Invite(this.client, data, this.serverId);
+    }
+    async fetch() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.serverInvites(this.serverId));
+        return new Collection_js_1.Collection(list.map((data) => [data.code, new ServerAssets_js_1.Invite(this.client, data, this.serverId)]));
+    }
+    async delete(code) {
+        await this.client.rest.delete(Routes_js_1.Routes.serverInvite(this.serverId, typeof code === 'string' ? code : code.code));
+    }
+}
+exports.InviteManager = InviteManager;

package/dist/cjs/managers/MemberManager.d.ts

@@ -0,0 +1,31 @@
+import type { Client } from '../client/Client.js';
+import { ServerMember } from '../structures/ServerMember.js';
+import type { User } from '../structures/User.js';
+import type { APIMember } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export interface Ban {
+    user: User;
+    reason: string | null;
+    createdAt: Date;
+}
+export declare class MemberManager extends CachedManager<ServerMember> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIMember): ServerMember;
+    get me(): ServerMember | null;
+    fetch(): Promise<Collection<string, ServerMember>>;
+    fetch(userId: string, options?: FetchOptions): Promise<ServerMember>;
+    kick(user: string | {
+        id: string;
+    }, reason?: string): Promise<void>;
+    ban(user: string | {
+        id: string;
+    }, options?: {
+        reason?: string;
+    }): Promise<void>;
+    unban(user: string | {
+        id: string;
+    }): Promise<void>;
+    fetchBans(): Promise<Collection<string, Ban>>;
+}

package/dist/cjs/managers/MemberManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberManager = void 0;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const Routes_js_1 = require("../rest/Routes.js");
+const ServerMember_js_1 = require("../structures/ServerMember.js");
+const Collection_js_1 = require("../util/Collection.js");
+const CachedManager_js_1 = require("./CachedManager.js");
+class MemberManager extends CachedManager_js_1.CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const user = this.client.users._add({ ...data.user, status: data.status ?? data.user.status, customStatus: data.customStatus ?? data.user.customStatus });
+        const existing = this.cache.get(user.id);
+        if (existing)
+            return existing._patch(data);
+        const member = new ServerMember_js_1.ServerMember(this.client, this.serverId, user, data);
+        this.cache.set(user.id, member);
+        return member;
+    }
+    get me() {
+        const id = this.client.user?.id;
+        return id ? (this.cache.get(id) ?? null) : null;
+    }
+    async fetch(userId, options = {}) {
+        if (userId !== undefined) {
+            const cached = this.cache.get(userId);
+            if (cached && !options.force)
+                return cached;
+        }
+        const list = await this.client.rest.get(Routes_js_1.Routes.serverMembers(this.serverId));
+        const all = new Collection_js_1.Collection();
+        for (const data of list)
+            all.set(data.user.id, this._add(data));
+        for (const id of this.cache.keys())
+            if (!all.has(id))
+                this.cache.delete(id);
+        if (userId === undefined)
+            return all;
+        const found = all.get(userId);
+        if (!found)
+            throw new BaffError_js_1.BaffError('UNKNOWN_MEMBER', `User ${userId} is not a member of server ${this.serverId}.`);
+        return found;
+    }
+    kick(user, reason) {
+        return this.client.rest.delete(Routes_js_1.Routes.serverMember(this.serverId, this.resolveId(user)), { body: reason ? { reason } : undefined });
+    }
+    ban(user, options = {}) {
+        return this.client.rest.put(Routes_js_1.Routes.serverBan(this.serverId, this.resolveId(user)), { body: options });
+    }
+    unban(user) {
+        return this.client.rest.delete(Routes_js_1.Routes.serverBan(this.serverId, this.resolveId(user)));
+    }
+    async fetchBans() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.serverBans(this.serverId));
+        return new Collection_js_1.Collection(list.map((b) => [b.user.id, { user: this.client.users._add(b.user), reason: b.reason, createdAt: new Date(b.createdAt) }]));
+    }
+}
+exports.MemberManager = MemberManager;

package/dist/cjs/managers/MessageManager.d.ts

@@ -0,0 +1,32 @@
+import { type MessageOptions } from '../builders/messagePayload.js';
+import type { TextBasedChannel } from '../structures/channels/TextBasedChannel.js';
+import { Message } from '../structures/Message.js';
+import type { APIMessage } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { type EmojiResolvable } from '../util/emoji.js';
+export interface FetchMessagesOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+    around?: string;
+}
+export declare class MessageManager {
+    readonly channel: TextBasedChannel;
+    readonly cache: Collection<string, Message>;
+    constructor(channel: TextBasedChannel);
+    private get client();
+    _add(data: APIMessage): Message;
+    _remove(id: string): Message | null;
+    private trim;
+    fetch(id: string, options?: {
+        force?: boolean;
+    }): Promise<Message>;
+    fetch(options?: FetchMessagesOptions): Promise<Collection<string, Message>>;
+    fetchPinned(): Promise<Collection<string, Message>>;
+    send(options: string | MessageOptions): Promise<Message>;
+    edit(id: string, options: string | MessageOptions): Promise<Message>;
+    delete(id: string): Promise<void>;
+    react(id: string, emoji: EmojiResolvable): Promise<void>;
+    pin(id: string): Promise<void>;
+    unpin(id: string): Promise<void>;
+}

package/dist/cjs/managers/MessageManager.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageManager = void 0;
+const messagePayload_js_1 = require("../builders/messagePayload.js");
+const BaffError_js_1 = require("../errors/BaffError.js");
+const Routes_js_1 = require("../rest/Routes.js");
+const Message_js_1 = require("../structures/Message.js");
+const Collection_js_1 = require("../util/Collection.js");
+const emoji_js_1 = require("../util/emoji.js");
+class MessageManager {
+    channel;
+    cache = new Collection_js_1.Collection();
+    constructor(channel) {
+        this.channel = channel;
+    }
+    get client() {
+        return this.channel.client;
+    }
+    _add(data) {
+        const existing = this.cache.get(data.id);
+        const message = existing ? existing._patch(data) : new Message_js_1.Message(this.client, data);
+        this.cache.delete(message.id);
+        this.cache.set(message.id, message);
+        this.trim();
+        return message;
+    }
+    _remove(id) {
+        const message = this.cache.get(id) ?? null;
+        this.cache.delete(id);
+        return message;
+    }
+    trim() {
+        const limit = this.client.options.messageCacheLimit;
+        while (this.cache.size > limit)
+            this.cache.delete(this.cache.firstKey());
+    }
+    async fetch(arg = {}, options = {}) {
+        if (typeof arg === 'string') {
+            const cached = this.cache.get(arg);
+            if (cached && !options.force)
+                return cached;
+            const list = await this.client.rest.get(Routes_js_1.Routes.channelMessages(this.channel.id), { query: { around: arg, limit: 1 } });
+            const found = list.find((m) => m.id === arg);
+            if (!found)
+                throw new BaffError_js_1.BaffAPIError(404, 'GET', Routes_js_1.Routes.channelMessage(this.channel.id, arg), { error: { code: 'unknown_message', message: 'Message not found.' } });
+            return this._add(found);
+        }
+        const list = await this.client.rest.get(Routes_js_1.Routes.channelMessages(this.channel.id), { query: { ...arg } });
+        return new Collection_js_1.Collection(list.map((data) => [data.id, this._add(data)]));
+    }
+    async fetchPinned() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.channelPins(this.channel.id));
+        return new Collection_js_1.Collection(list.map((data) => [data.id, this._add(data)]));
+    }
+    async send(options) {
+        const { body, files } = (0, messagePayload_js_1.resolveMessage)(options);
+        const data = await this.client.rest.post(Routes_js_1.Routes.channelMessages(this.channel.id), { body, files });
+        return this._add({ serverId: this.channel.serverId, ...data });
+    }
+    async edit(id, options) {
+        const { body } = (0, messagePayload_js_1.resolveMessage)(options);
+        const data = await this.client.rest.patch(Routes_js_1.Routes.channelMessage(this.channel.id, id), { body });
+        return this._add({ serverId: this.channel.serverId, ...data });
+    }
+    async delete(id) {
+        await this.client.rest.delete(Routes_js_1.Routes.channelMessage(this.channel.id, id));
+        this._remove(id);
+    }
+    async react(id, emoji) {
+        await this.client.rest.put(Routes_js_1.Routes.messageReaction(this.channel.id, id, (0, emoji_js_1.resolveEmoji)(emoji)));
+    }
+    async pin(id) {
+        await this.client.rest.put(Routes_js_1.Routes.channelPin(this.channel.id, id));
+    }
+    async unpin(id) {
+        await this.client.rest.delete(Routes_js_1.Routes.channelPin(this.channel.id, id));
+    }
+}
+exports.MessageManager = MessageManager;

package/dist/cjs/managers/RoleManager.d.ts

@@ -0,0 +1,22 @@
+import type { Client } from '../client/Client.js';
+import { Role, type RoleEditData } from '../structures/Role.js';
+import type { APIRole } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager } from './CachedManager.js';
+export declare class RoleManager extends CachedManager<Role> {
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    _add(data: APIRole): Role;
+    _setAll(list: APIRole[]): {
+        created: Role[];
+        updated: [Role, Role][];
+        deleted: Role[];
+    };
+    get everyone(): Role | null;
+    get highest(): Role | null;
+    fetch(): Promise<Collection<string, Role>>;
+    create(data?: RoleEditData): Promise<Role>;
+    edit(role: string | Role, data: RoleEditData): Promise<Role>;
+    delete(role: string | Role): Promise<void>;
+    reorder(ids: string[]): Promise<void>;
+}

package/dist/cjs/managers/RoleManager.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+const Role_js_1 = require("../structures/Role.js");
+const CachedManager_js_1 = require("./CachedManager.js");
+class RoleManager extends CachedManager_js_1.CachedManager {
+    serverId;
+    constructor(client, serverId) {
+        super(client);
+        this.serverId = serverId;
+    }
+    _add(data) {
+        const existing = this.cache.get(data.id);
+        if (existing)
+            return existing._patch(data);
+        const role = new Role_js_1.Role(this.client, this.serverId, data);
+        this.cache.set(role.id, role);
+        return role;
+    }
+    _setAll(list) {
+        const created = [];
+        const updated = [];
+        const seen = new Set();
+        for (const data of list) {
+            seen.add(data.id);
+            const existing = this.cache.get(data.id);
+            if (!existing)
+                created.push(this._add(data));
+            else
+                updated.push([existing._clone(), this._add(data)]);
+        }
+        const deleted = [];
+        for (const [id, role] of [...this.cache]) {
+            if (!seen.has(id)) {
+                this.cache.delete(id);
+                deleted.push(role);
+            }
+        }
+        return { created, updated, deleted };
+    }
+    get everyone() {
+        return this.cache.get(this.serverId) ?? null;
+    }
+    get highest() {
+        return this.cache.toSorted((a, b) => b.position - a.position).first() ?? null;
+    }
+    async fetch() {
+        this._setAll(await this.client.rest.get(Routes_js_1.Routes.serverRoles(this.serverId)));
+        return this.cache;
+    }
+    async create(data = {}) {
+        const created = await this.client.rest.post(Routes_js_1.Routes.serverRoles(this.serverId), { body: data.name ? { name: data.name } : {} });
+        const role = this._add(created);
+        const { name: _name, ...rest } = data;
+        return Object.keys(rest).length ? role.edit(rest) : role;
+    }
+    async edit(role, data) {
+        const target = typeof role === 'string' ? this.cache.get(role) : role;
+        if (target)
+            return target.edit(data);
+        return this._add(await this.client.rest.patch(Routes_js_1.Routes.serverRole(this.serverId, role), { body: (0, Role_js_1.roleEditBody)(data) }));
+    }
+    async delete(role) {
+        const id = this.resolveId(role);
+        await this.client.rest.delete(Routes_js_1.Routes.serverRole(this.serverId, id));
+        this.cache.delete(id);
+    }
+    async reorder(ids) {
+        await this.client.rest.put(Routes_js_1.Routes.serverRoles(this.serverId), { body: { ids } });
+    }
+}
+exports.RoleManager = RoleManager;

package/dist/cjs/managers/ServerChannelManager.d.ts

@@ -0,0 +1,20 @@
+import type { Client } from '../client/Client.js';
+import type { Channel, ServerChannel } from '../structures/channels/ServerChannels.js';
+import type { ChannelKind } from '../types.js';
+import type { Collection } from '../util/Collection.js';
+export interface CreateChannelOptions {
+    name: string;
+    kind?: Exclude<ChannelKind, 'thread' | 'dm' | 'group_dm' | 'stage'>;
+    parentId?: string | null;
+}
+export declare class ServerChannelManager {
+    private readonly client;
+    readonly serverId: string;
+    constructor(client: Client, serverId: string);
+    get cache(): Collection<string, ServerChannel>;
+    create(options: CreateChannelOptions): Promise<ServerChannel>;
+    delete(channel: string | {
+        id: string;
+    }): Promise<void>;
+    resolve(id: string): Channel | null;
+}

package/dist/cjs/managers/ServerChannelManager.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerChannelManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+class ServerChannelManager {
+    client;
+    serverId;
+    constructor(client, serverId) {
+        this.client = client;
+        this.serverId = serverId;
+    }
+    get cache() {
+        return this.client.channels.forServer(this.serverId);
+    }
+    async create(options) {
+        const data = await this.client.rest.post(Routes_js_1.Routes.serverChannels(this.serverId), {
+            body: { name: options.name, kind: options.kind ?? 'text', parentId: options.parentId ?? null }
+        });
+        return this.client.channels._upsert({ ...data, serverId: this.serverId });
+    }
+    async delete(channel) {
+        const id = typeof channel === 'string' ? channel : channel.id;
+        await this.client.rest.delete(Routes_js_1.Routes.channel(id));
+        this.client.channels._remove(id);
+    }
+    resolve(id) {
+        return this.cache.get(id) ?? null;
+    }
+}
+exports.ServerChannelManager = ServerChannelManager;

package/dist/cjs/managers/ServerManager.d.ts

@@ -0,0 +1,12 @@
+import { Server } from '../structures/Server.js';
+import type { APIServer, APIServerSummary } from '../types.js';
+import { Collection } from '../util/Collection.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export declare class ServerManager extends CachedManager<Server> {
+    _add(data: APIServerSummary | APIServer): Server;
+    _remove(id: string): Server | null;
+    fetch(): Promise<Collection<string, Server>>;
+    fetch(id: string, options?: FetchOptions): Promise<Server>;
+    fetch(id: undefined, options: FetchOptions): Promise<Collection<string, Server>>;
+    leave(id: string): Promise<void>;
+}

package/dist/cjs/managers/ServerManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+const Server_js_1 = require("../structures/Server.js");
+const Collection_js_1 = require("../util/Collection.js");
+const CachedManager_js_1 = require("./CachedManager.js");
+const isDetail = (data) => 'channels' in data && 'roles' in data;
+class ServerManager extends CachedManager_js_1.CachedManager {
+    _add(data) {
+        let server = this.cache.get(data.id);
+        if (!server) {
+            server = new Server_js_1.Server(this.client, data);
+            this.cache.set(server.id, server);
+        }
+        else {
+            server._patch(data);
+        }
+        if (isDetail(data))
+            server._applyDetail(data);
+        return server;
+    }
+    _remove(id) {
+        const server = this.cache.get(id) ?? null;
+        this.cache.delete(id);
+        for (const channel of server?.channels.cache.values() ?? [])
+            this.client.channels._remove(channel.id);
+        return server;
+    }
+    async fetch(id, options = {}) {
+        if (id !== undefined) {
+            const cached = this.cache.get(id);
+            if (cached?.detailed && !options.force)
+                return cached;
+            return this._add(await this.client.rest.get(Routes_js_1.Routes.server(id)));
+        }
+        const list = await this.client.rest.get(Routes_js_1.Routes.servers());
+        const out = new Collection_js_1.Collection();
+        const queue = [...list];
+        const worker = async () => {
+            for (let next = queue.shift(); next; next = queue.shift()) {
+                try {
+                    out.set(next.id, this._add(await this.client.rest.get(Routes_js_1.Routes.server(next.id))));
+                }
+                catch (error) {
+                    this.client.emit('debug', `Could not load server ${next.id}: ${error.message}`);
+                    out.set(next.id, this._add(next));
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(4, queue.length) }, worker));
+        for (const id of this.cache.keys())
+            if (!list.some((s) => s.id === id))
+                this._remove(id);
+        return out;
+    }
+    async leave(id) {
+        await this.client.rest.delete(Routes_js_1.Routes.serverLeave(id));
+        this._remove(id);
+    }
+}
+exports.ServerManager = ServerManager;

package/dist/cjs/managers/ThreadManager.d.ts

@@ -0,0 +1,12 @@
+import type { TextChannel, ThreadChannel } from '../structures/channels/ServerChannels.js';
+import { Collection } from '../util/Collection.js';
+export declare class ThreadManager {
+    private readonly channel;
+    constructor(channel: TextChannel);
+    create(options: {
+        name: string;
+        messageId?: string;
+        autoArchiveMinutes?: 60 | 1440 | 4320 | 10080;
+    }): Promise<ThreadChannel>;
+    fetch(): Promise<Collection<string, ThreadChannel>>;
+}

package/dist/cjs/managers/ThreadManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+const Collection_js_1 = require("../util/Collection.js");
+class ThreadManager {
+    channel;
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async create(options) {
+        const data = await this.channel.client.rest.post(Routes_js_1.Routes.channelThreads(this.channel.id), { body: options });
+        return this.channel.client.channels._addThread(data);
+    }
+    async fetch() {
+        const list = await this.channel.client.rest.get(Routes_js_1.Routes.channelThreads(this.channel.id));
+        return new Collection_js_1.Collection(list.map((data) => [data.id, this.channel.client.channels._addThread(data)]));
+    }
+}
+exports.ThreadManager = ThreadManager;

package/dist/cjs/managers/UserManager.d.ts

@@ -0,0 +1,11 @@
+import type { DMChannel } from '../structures/channels/DMChannel.js';
+import { User } from '../structures/User.js';
+import type { APIUser } from '../types.js';
+import { CachedManager, type FetchOptions } from './CachedManager.js';
+export declare class UserManager extends CachedManager<User> {
+    private readonly tags;
+    _add(data: APIUser): User;
+    fetchTags(): Promise<void>;
+    fetch(id: string, options?: FetchOptions): Promise<User>;
+    createDM(userId: string): Promise<DMChannel>;
+}

package/dist/cjs/managers/UserManager.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+const User_js_1 = require("../structures/User.js");
+const CachedManager_js_1 = require("./CachedManager.js");
+class UserManager extends CachedManager_js_1.CachedManager {
+    tags = new Map();
+    _add(data) {
+        const known = data.tag === undefined ? this.tags.get(data.id) : undefined;
+        const patch = known ? { ...data, tag: known } : data;
+        const existing = this.cache.get(data.id);
+        if (existing)
+            return existing._patch(patch);
+        const user = new User_js_1.User(this.client, patch);
+        this.cache.set(user.id, user);
+        return user;
+    }
+    async fetchTags() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.userTags());
+        for (const { id, tag } of list) {
+            this.tags.set(id, tag);
+            this.cache.get(id)?._patch({ tag });
+        }
+    }
+    async fetch(id, options = {}) {
+        const cached = this.cache.get(id);
+        if (cached && !options.force)
+            return cached;
+        const profile = await this.client.rest.get(Routes_js_1.Routes.userProfile(id));
+        return this._add(profile.user);
+    }
+    async createDM(userId) {
+        const data = await this.client.rest.post(Routes_js_1.Routes.dms(), { body: { recipientId: userId } });
+        return this.client.channels._addDM(data);
+    }
+}
+exports.UserManager = UserManager;

package/dist/cjs/managers/VoiceManager.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from '../client/Client.js';
+import type { APIVoiceJoin } from '../types.js';
+export declare class VoiceManager {
+    private readonly client;
+    constructor(client: Client);
+    join(channelId: string): Promise<APIVoiceJoin>;
+    leave(serverId?: string): Promise<void>;
+}

package/dist/cjs/managers/VoiceManager.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceManager = void 0;
+const Routes_js_1 = require("../rest/Routes.js");
+class VoiceManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    join(channelId) {
+        return this.client.rest.post(Routes_js_1.Routes.channelVoice(channelId));
+    }
+    async leave(serverId) {
+        await this.client.rest.delete(Routes_js_1.Routes.voice(), { query: { serverId } });
+    }
+}
+exports.VoiceManager = VoiceManager;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/rest/REST.d.ts

@@ -0,0 +1,58 @@
+import { TypedEmitter } from '../util/TypedEmitter.js';
+import { type RawFile } from './files.js';
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type QueryValue = string | number | boolean | undefined | null | readonly (string | number)[];
+export interface RESTOptions {
+    api?: string;
+    token?: string;
+    timeout?: number;
+    retries?: number;
+    maxRateLimitRetries?: number;
+    userAgent?: string;
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    query?: Record<string, QueryValue>;
+    body?: unknown;
+    files?: readonly RawFile[];
+    auth?: boolean;
+    signal?: AbortSignal;
+    raw?: boolean;
+}
+export interface RateLimitInfo {
+    method: HTTPMethod;
+    path: string;
+    retryAfter: number;
+    global: boolean;
+}
+type RESTEvents = {
+    rateLimited: [RateLimitInfo];
+    debug: [string];
+};
+export declare function bucketKey(method: HTTPMethod, path: string): string;
+export declare class REST extends TypedEmitter<RESTEvents> {
+    readonly api: string;
+    token: string | null;
+    private readonly timeout;
+    private readonly retries;
+    private readonly maxRateLimitRetries;
+    private readonly userAgent;
+    private readonly fetchImpl;
+    private readonly buckets;
+    private readonly sent;
+    private globalBlockedUntil;
+    constructor(options?: RESTOptions);
+    setToken(token: string): this;
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    request<T = unknown>(method: HTTPMethod, path: string, options?: RequestOptions): Promise<T>;
+    private send;
+    private waitTurn;
+    private url;
+    private init;
+    private backoff;
+}
+export {};