snowtransfer 0.17.7 → 0.18.1

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# 0.18.1
+A few bugs I failed to catch last round. Sorry about that.
+
+- Fixed request retries with retryRequests/retryFailed deadlocking the route's rate limit bucket.
+	- The retry was enqueued into the same bucket that was blocked waiting for the retry to finish, so the request promise never settled and every later request on that route hung forever. Retries now free the bucket before re-queueing.
+	- Retries also now preserve the rawResponse flag. Previously a retried InviteMethods#getInviteTargetUsers would explode because it got parsed JSON instead of a Response.
+- Fixed the baseURL option being silently ignored by the RequestHandler. It's also exposed on the SnowTransfer options now, along with a custom fetch implementation.
+- Requests without a body no longer send the literal string "undefined" as the JSON body (with a Content-Type to match). Discord tolerated it, but yuck.
+- DiscordAPIError#code is now the actual Discord error code (e.g. 10008 Unknown Message) parsed from JSON error bodies instead of always being 4000. Validation error details are still included in the message.
+- Bucket cooldowns now only wait on the counters that are actually exhausted. Previously the wait was the max across all counters, so e.g. reaction routes with a 250ms reset could stall for up to a second on the global counter's window.
+- 400 responses are no longer retried when retryRequests is enabled. Retrying a malformed request was never going to go differently.
+- The hourly bucket sweep no longer deletes buckets that still have queued calls or are mid-cooldown, which could briefly let two buckets for the same route run in parallel.
+- ChannelMethods#createVoiceMessage now uses the configured fetch implementation for the CDN upload, actually checks that the upload succeeded, and uses MessageFlags.IsVoiceMessage instead of a magic number.
+- Query params/data objects passed to methods are no longer mutated (appendQuery deleted undefined keys from your object, createInteractionResponse wrote allowed_mentions into your data).
+	- This is now backed by Constants#cloneUserInput, which copies payloads before the library writes to them: plain objects and arrays are deep cloned, while Buffers, Blobs and streams are intentionally shared by reference (copying those is either wasteful or impossible). Your payloads stay reusable across calls and retries.
+- The file property of files now also accepts a factory function returning (or resolving to) a file, and Blob/File are now properly advertised in the method signatures (the form handler always supported them).
+	- Streams are single use - once a request consumed one, sending the same payload again would upload nothing. Pass file: () => fs.createReadStream(path) and the factory is called once per materialization, so reusing the payload just works. The new FileInput and SendableFile types document this right where your editor's hover can see it.
+- Fixed multipart uploads crashing with "Received non-Uint8Array chunk" when given a Readable that emits strings (e.g. Readable.from(["text"])). Stream contents are now collected through Blob, which is fine with string and Buffer chunks alike.
+- WebhookMethods#executeWebhook now treats empty embeds/components/files arrays as missing, matching ChannelMethods#createMessage.
+- Fixed the JSDoc example for AssetsMethods#createGuildSticker passing tags as an array - it's a comma separated string.
+- strings added to forms without a filename param route through the overload for strings instead of wrapping them in a Blob
+- Tokens are only considered pre-prefixed if they start with "Bot " or "Bearer " (with the space).
+- Fixed the StateMachine onEnter error message naming the wrong state.
+- Added a test suite (node:test, no new dependencies, `npm test`) covering the ratelimiter/request handler core, request transformations, client-side validation, and pure functions. Deliberately no fixture tests of endpoint wrappers - those only test the mock.
+- Removed dep on broken tsup.
+	- This also allows the emitted code to be more readable which eliminates the "need" for a sourcemap.
+	- Also fixes needing to use funny naming schemes for imports of classes across different files lest tsup minification for the dts and js would start naming the base class something else entirely and wrap it instead of.. yknow. Using the name the dev defined even though it'd be valid in that context.
+- Removed @protected tag from classes so that they'd be visible in the docs by default.
+
+# 0.18.0
+First entry in this changelog. This is a major one - possibly the biggest one save for the js -> ts rewrite. We'll start with the most interesting/impactful.
+
+- Consistency changes across the board. This includes method names, code formatting, etc. (I finally updated eslint to v10)
+	- This is quite a few breaking changes and makes up a good chunk of this update. The original method names didn't get a redirect to the new ones. Sorry in advance for the migration struggle.
+	- I had to struggle migrating Discord.js a few times, don't think this library is safe from the same struggles >:D jk. I think this will be the only time this kinda thing happens.
+	- PATCH methods have been changed from a mix of update/edit/??? prefixes to just edit* preferably. Some methods are special snowflakes.
+	- DELETE methods have been changed to prefix with delete*
+	- Bulk methods like channel bulk delete messages was simplified to deleteMessages. There were more though.
+	- SkuMethods#getSkus was SkuMethods#GetSkus (PascalCase instead of camelCase like literally every other method)
+- Found and fixed some actual bugs.
+	- GuildScheduledEventMethods#getGuildScheduledEvent and UserMethods#getGuild was accidentally passing the query string params to the JSON body param for the request.
+	- IntervalCounter#take would continue to decrement remaining past 0 into the negatives. It would still return false regardless, but this could probably have been problematic in external use cases outside of this lib.
+	- request retry logic would go indefinitely instead of decrementing the remaining amount.
+- Removed some types being exported from the package.
+	- These types were actually just straight up deleted as discord-api-types added them.
+- Added a generateWaveform function to Constants.
+	- This function is supposed to be used for ChannelMethods#createVoiceMessage, but it doesn't do the whole thing for you. Please read the JSDoc for it!
+	- Huge thank you to @Lulalaby for her original C# implementation.
+- Removed any lingering references to removeEveryone.
+- Fixed some errors with docs.
+	- Some of it was spelling related.
+	- Some docs entries had invalid JS in it, so anyone who copy pasted and saw an error... Oops! My bad.
+- Changed some method return types to be from discord-api-types.
+	- Previously for HTTP 204 routes, the return type was never, which was incorrect and made some design patterns, specifically mock test writing annoying as you cannot naturally return the type never in JS without unconditionally throwing an Error or calling process.exit()
+	- A PR from yours truly changed it to undefined. I had changed them to void locally for a bit and commented out the types from dapi types, but now that's fixed so they're back.
+- VSCode settings deprecated the setting originally used to specify the TS version in editor, so the path was changed.
+- Deleted the old travis.yml
+- Updated the examples.
+- Added a build script that runs both build:src and build:docs.
+- Added a lint script.

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 DasWolke
+Copyright (c) 2026 DasWolke
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -26,6 +26,8 @@ I've written a general whitepaper on the idea of microservice bots, which you ca
 ### Documentation:
 You can find the docs at [https://daswolke.github.io/SnowTransfer/](https://daswolke.github.io/SnowTransfer/)
 
+For a changelog, read here: [Changelog](./CHANGELOG.md)
+
 ### Installation:
 To install SnowTransfer, make sure that you have node 22.0.0 or higher and npm installed on your computer.
 
@@ -35,11 +37,8 @@ Then run the following command in a terminal `npm install snowtransfer`
 ```js
 const { SnowTransfer } = require('snowtransfer');
 const client = new SnowTransfer('DISCORD BOT TOKEN');
-const request = async () => {
-	const message = await client.channel.createMessage('channel id', 'hi there');
-	console.log(message);
-};
-request().then(() => {
+
+client.channel.createMessage('channel id', 'hi there').then(() => {
 	// message was sent to discord
 }).catch(e => {
 	// an error occurred

package/dist/Constants.d.ts

@@ -0,0 +1,59 @@
+import type { FileInput } from "./Types";
+declare const Constants: {
+    REST_API_VERSION: 10;
+    GET_CHANNEL_MESSAGES_MIN_RESULTS: 1;
+    GET_CHANNEL_MESSAGES_MAX_RESULTS: 100;
+    GET_GUILD_SCHEDULED_EVENT_USERS_MIN_RESULTS: 1;
+    GET_GUILD_SCHEDULED_EVENT_USERS_MAX_RESULTS: 100;
+    SEARCH_MEMBERS_MIN_RESULTS: 1;
+    SEARCH_MEMBERS_MAX_RESULTS: 1000;
+    BULK_DELETE_MESSAGES_MIN: 2;
+    BULK_DELETE_MESSAGES_MAX: 100;
+    OK_STATUS_CODES: Set<number>;
+    DO_NOT_RETRY_STATUS_CODES: Set<number>;
+    DEFAULT_RETRY_LIMIT: number;
+    GLOBAL_REQUESTS_PER_SECOND: number;
+    /**
+     * Deep clones arrays and plain objects, passing everything else (Buffers, Blobs, streams, class instances) through by reference.
+     *
+     * Used to copy user supplied payloads before the library writes to them (defaulting allowed_mentions, deleting keys, etc),
+     * so the caller's objects stay reusable across calls and are unchanged by retries. Exotic values are intentionally shared,
+     * since they are either wasteful (Buffer) or impossible (streams) to copy.
+     * @since 0.18.1
+     * @param value Value to clone
+     */
+    cloneUserInput<T>(value: T): T;
+    standardMultipartHandler(data: {
+        files: Array<{
+            name: string;
+            file: FileInput;
+        }>;
+        data?: any;
+    }): Promise<FormData>;
+    standardAddToFormHandler(form: FormData, name: string, value: string | FileInput, filename?: string): Promise<void>;
+    reasonHeader(reason?: string): {
+        "X-Audit-Log-Reason"?: string;
+    };
+    /**
+     * Generates a waveform from mono PCM samples
+     *
+     * Discord expects 1 byte per datapoint (0-255), at most 256 datapoints, base64 encoded.
+     * SnowTransfer does not do the whole process of converting the audio Buffer to a waveform string,
+     * since doing so properly requires decoding the actual audio (Opus, MP3, AAC, FLAC, ...) into raw PCM samples,
+     * and that needs a real audio codec library or an `ffmpeg` binary, neither of which this package depends on.
+     *
+     * This function just does the important part - chunking samples sequentially in time (not interleaving/round-robin),
+     * so each byte represents the amplitude of one time slice of the recording, left to right.
+     *
+     * To get `pcmSamples` in the first place:
+     * WAV is the only format decodable without extra tooling, since it's just a header followed by raw PCM.
+     * For Ogg/Opus, MP3, M4A, FLAC, etc., you'll need to decode to PCM first, e.g. by shelling out to ffmpeg
+     * (`ffmpeg -i input -f s16le -ac 1 -ar 48000 -`) or using a native/wasm decoder of your choice.
+     * prism-media is an option and is the backend of discord.js' voice package for the purpose of converting arbitrary
+     * audio formats into PCM for some functionality, like gain modification, to then convert into opus packets for Discord.
+     * Though it does depend on ffmpeg for unrecognized formats.
+     * @param pcmSamples mono PCM, e.g. Int16 samples in the range -32768..32767
+     */
+    generateWaveform(pcmSamples: Array<number>, durationSeconds: number, maxPoints?: number): string;
+};
+export = Constants;

package/dist/Constants.js

@@ -0,0 +1,123 @@
+"use strict";
+const node_stream_1 = require("node:stream");
+const Constants = {
+    REST_API_VERSION: 10,
+    GET_CHANNEL_MESSAGES_MIN_RESULTS: 1,
+    GET_CHANNEL_MESSAGES_MAX_RESULTS: 100,
+    GET_GUILD_SCHEDULED_EVENT_USERS_MIN_RESULTS: 1,
+    GET_GUILD_SCHEDULED_EVENT_USERS_MAX_RESULTS: 100,
+    SEARCH_MEMBERS_MIN_RESULTS: 1,
+    SEARCH_MEMBERS_MAX_RESULTS: 1000,
+    BULK_DELETE_MESSAGES_MIN: 2,
+    BULK_DELETE_MESSAGES_MAX: 100,
+    OK_STATUS_CODES: new Set([200, 201, 204, 304]),
+    DO_NOT_RETRY_STATUS_CODES: new Set([400, 401, 403, 404, 405, 411, 413]),
+    DEFAULT_RETRY_LIMIT: 3,
+    GLOBAL_REQUESTS_PER_SECOND: 50,
+    /**
+     * Deep clones arrays and plain objects, passing everything else (Buffers, Blobs, streams, class instances) through by reference.
+     *
+     * Used to copy user supplied payloads before the library writes to them (defaulting allowed_mentions, deleting keys, etc),
+     * so the caller's objects stay reusable across calls and are unchanged by retries. Exotic values are intentionally shared,
+     * since they are either wasteful (Buffer) or impossible (streams) to copy.
+     * @since 0.18.1
+     * @param value Value to clone
+     */
+    cloneUserInput(value) {
+        if (Array.isArray(value))
+            return value.map(v => Constants.cloneUserInput(v));
+        if (value !== null && typeof value === "object") {
+            const proto = Object.getPrototypeOf(value);
+            if (proto === Object.prototype || proto === null) {
+                const cloned = {};
+                for (const [key, v] of Object.entries(value)) {
+                    cloned[key] = Constants.cloneUserInput(v);
+                }
+                return cloned;
+            }
+        }
+        return value;
+    },
+    async standardMultipartHandler(data) {
+        const form = new FormData();
+        // Cloned so the deletes below can't spend the caller's payload. File contents are shared by reference, not copied
+        const payload = Constants.cloneUserInput(data);
+        if (payload.files && Array.isArray(payload.files) && payload.files.every(f => !!f.name && !!f.file)) {
+            let index = 0;
+            for (const file of payload.files) {
+                await Constants.standardAddToFormHandler(form, `files[${index}]`, file.file, file.name);
+                // @ts-expect-error Cannot delete non optional, but I have to
+                delete file.file;
+                index++;
+            }
+        }
+        // @ts-expect-error Cannot delete non optional, but I have to
+        if (payload.data)
+            delete payload.files; // Interactions responses are weird, but I need to support it
+        form.append("payload_json", JSON.stringify(payload));
+        return form;
+    },
+    async standardAddToFormHandler(form, name, value, filename) {
+        // Factories produce a fresh file per materialization, so payloads containing streams can be reused across calls
+        if (typeof value === "function")
+            value = await value();
+        if (typeof value === "string" && !filename)
+            form.append(name, value);
+        // @ts-expect-error It's a Buffer and it works. If node changes the backend to not accept a plain Buffer, then we can talk
+        else if (value instanceof Buffer || typeof value === "string")
+            form.append(name, new Blob([value]), filename);
+        else if (value instanceof Blob || value instanceof File)
+            form.append(name, value, filename);
+        // Node Readables may emit string or Buffer chunks; Blob accepts both as parts, unlike Response which only takes bytes
+        else if (value instanceof node_stream_1.Readable)
+            form.set(name, new Blob(await value.toArray()), filename);
+        else if (value instanceof ReadableStream)
+            form.set(name, await new Response(value).blob(), filename);
+        else
+            throw new Error(`Don't know how to add ${value?.constructor?.name ?? typeof value} to form`);
+    },
+    reasonHeader(reason) {
+        return reason ? { "X-Audit-Log-Reason": reason } : {};
+    },
+    /**
+     * Generates a waveform from mono PCM samples
+     *
+     * Discord expects 1 byte per datapoint (0-255), at most 256 datapoints, base64 encoded.
+     * SnowTransfer does not do the whole process of converting the audio Buffer to a waveform string,
+     * since doing so properly requires decoding the actual audio (Opus, MP3, AAC, FLAC, ...) into raw PCM samples,
+     * and that needs a real audio codec library or an `ffmpeg` binary, neither of which this package depends on.
+     *
+     * This function just does the important part - chunking samples sequentially in time (not interleaving/round-robin),
+     * so each byte represents the amplitude of one time slice of the recording, left to right.
+     *
+     * To get `pcmSamples` in the first place:
+     * WAV is the only format decodable without extra tooling, since it's just a header followed by raw PCM.
+     * For Ogg/Opus, MP3, M4A, FLAC, etc., you'll need to decode to PCM first, e.g. by shelling out to ffmpeg
+     * (`ffmpeg -i input -f s16le -ac 1 -ar 48000 -`) or using a native/wasm decoder of your choice.
+     * prism-media is an option and is the backend of discord.js' voice package for the purpose of converting arbitrary
+     * audio formats into PCM for some functionality, like gain modification, to then convert into opus packets for Discord.
+     * Though it does depend on ffmpeg for unrecognized formats.
+     * @param pcmSamples mono PCM, e.g. Int16 samples in the range -32768..32767
+     */
+    generateWaveform(pcmSamples, durationSeconds, maxPoints = 256) {
+        if (maxPoints > 256)
+            maxPoints = 256;
+        const points = Math.min(maxPoints, Math.ceil(durationSeconds * 10)); // Discord samples at most once per 100ms
+        const chunkSize = Math.ceil(pcmSamples.length / points);
+        const waveformArr = [];
+        for (let i = 0; i < points; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, pcmSamples.length);
+            const chunk = pcmSamples.slice(start, end);
+            if (chunk.length === 0) {
+                waveformArr[i] = 0;
+                continue;
+            }
+            const sumSquares = chunk.reduce((acc, cur) => acc + (cur * cur), 0);
+            const rms = Math.sqrt(sumSquares / chunk.length); // root-mean-square amplitude of this chunk
+            waveformArr[i] = Math.round((rms / 32768) * 255);
+        }
+        return Buffer.from(waveformArr).toString("base64");
+    }
+};
+module.exports = Constants;

package/dist/Endpoints.d.ts

@@ -0,0 +1,120 @@
+import Constants = require("./Constants");
+/**
+ * Mostly taken from https://github.com/abalabahaha/eris/blob/master/lib/rest/Endpoints.js
+ *
+ * Removed User-only endpoints
+ */
+declare const Endpoints: {
+    BASE_URL: `/api/v${typeof Constants.REST_API_VERSION}`;
+    BASE_HOST: "https://discord.com";
+    CDN_URL: "https://cdn.discordapp.com";
+    APPLICATION_COMMAND: (appId: string, cmdId: string) => `${ReturnType<typeof Endpoints.APPLICATION_COMMANDS>}/{cmd_id}`;
+    APPLICATION_COMMANDS: (appId: string) => "/applications/{app_id}/commands";
+    APPLICATION_EMOJI: (appId: string, emojiId: string) => `${ReturnType<typeof Endpoints.APPLICATION_EMOJIS>}/{emoji_id}`;
+    APPLICATION_EMOJIS: (appId: string) => "/applications/{app_id}/emojis";
+    APPLICATION_ENTITLEMENT: (appId: string, entitlementId: string) => `${ReturnType<typeof Endpoints.APPLICATION_ENTITLEMENTS>}/{entitlement_id}`;
+    APPLICATION_ENTITLEMENT_CONSUME: (appId: string, entitlementId: string) => `${ReturnType<typeof Endpoints.APPLICATION_ENTITLEMENT>}/consume`;
+    APPLICATION_ENTITLEMENTS: (appId: string) => "/applications/{app_id}/entitlements";
+    APPLICATION_GUILD_COMMANDS_PERMISSIONS: (appId: string, guildId: string) => `${ReturnType<typeof Endpoints.APPLICATION_GUILD_COMMANDS>}/permissions`;
+    APPLICATION_GUILD_COMMAND_PERMISSIONS: (appId: string, guildId: string, cmdId: string) => `${ReturnType<typeof Endpoints.APPLICATION_GUILD_COMMAND>}/permissions`;
+    APPLICATION_GUILD_COMMAND: (appId: string, guildId: string, cmdId: string) => `${ReturnType<typeof Endpoints.APPLICATION_GUILD_COMMANDS>}/{cmd_id}`;
+    APPLICATION_GUILD_COMMANDS: (appId: string, guildId: string) => "/applications/{app_id}/guilds/{guild_id}/commands";
+    APPLICATION_SKUS: (appId: string) => "/applications/{app_id}/skus";
+    ATTACHMENTS_REFRESH_URLS: "/attachments/refresh-urls";
+    CHANNEL: (chanId: string) => `${typeof Endpoints.CHANNELS}/{channel_id}`;
+    CHANNEL_ATTACHMENTS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/attachments`;
+    CHANNEL_BULK_DELETE: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGES>}/bulk-delete`;
+    CHANNEL_FOLLOWERS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/followers`;
+    CHANNEL_INVITES: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/invites`;
+    CHANNEL_MESSAGE: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGES>}/{message_id}`;
+    CHANNEL_MESSAGE_CROSSPOST: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGE>}/crosspost`;
+    CHANNEL_MESSAGE_REACTION: (chanId: string, msgId: string, reaction: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGE_REACTIONS>}/{reaction}`;
+    CHANNEL_MESSAGE_REACTION_USER: (chanId: string, msgId: string, reaction: string, userId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGE_REACTION>}/{user_id}`;
+    CHANNEL_MESSAGE_REACTIONS: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGE>}/reactions`;
+    CHANNEL_MESSAGE_THREADS: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL_MESSAGE>}/threads`;
+    CHANNEL_MESSAGES: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/messages`;
+    CHANNEL_PERMISSION: (chanId: string, permId: string) => `${ReturnType<typeof Endpoints.CHANNEL_PERMISSIONS>}/{perm_id}`;
+    CHANNEL_PERMISSIONS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/permissions`;
+    CHANNEL_PIN: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL_PINS>}/{message_id}`;
+    CHANNEL_PINS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/messages/pins`;
+    CHANNEL_RECIPIENT: (chanId: string, userId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/recipients/{user_id}`;
+    CHANNEL_THREADS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/threads`;
+    CHANNEL_THREAD_MEMBER: (chanId: string, memberId: string) => `${ReturnType<typeof Endpoints.CHANNEL_THREAD_MEMBERS>}/{member_id}`;
+    CHANNEL_THREAD_MEMBERS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/thread-members`;
+    CHANNEL_THREADS_ARCHIVED_PRIVATE: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL_THREADS>}/archived/private`;
+    CHANNEL_THREADS_ARCHIVED_PRIVATE_USER: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/users/@me/threads/archived/private`;
+    CHANNEL_THREADS_ARCHIVED_PUBLIC: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL_THREADS>}/archived/public`;
+    CHANNEL_TYPING: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/typing`;
+    CHANNEL_VOICE_STATUS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/voice-status`;
+    CHANNEL_VOICE_HANGOUT: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/voice-hangout`;
+    CHANNEL_WEBHOOKS: (chanId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/webhooks`;
+    CHANNELS: "/channels";
+    GATEWAY: "/gateway";
+    GATEWAY_BOT: "/gateway/bot";
+    GUILD: (guildId: string) => `${typeof Endpoints.GUILDS}/{guild_id}`;
+    GUILD_AUDIT_LOGS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/audit-logs`;
+    GUILD_AUTO_MOD_RULE: (guildId: string, ruleId: string) => `${ReturnType<typeof Endpoints.GUILD_AUTO_MOD_RULES>}/{rule_id}`;
+    GUILD_AUTO_MOD_RULES: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/auto-moderation/rules`;
+    GUILD_BAN: (guildId: string, memberId: string) => `${ReturnType<typeof Endpoints.GUILD_BANS>}/{member_id}`;
+    GUILD_BANS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/bans`;
+    GUILD_CHANNELS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/channels`;
+    GUILD_EMOJI: (guildId: string, emojiId: string) => `${ReturnType<typeof Endpoints.GUILD_EMOJIS>}/{emoji_id}`;
+    GUILD_EMOJIS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/emojis`;
+    GUILD_INVITES: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/invites`;
+    GUILD_INTEGRATION: (guildId: string, integrationId: string) => `${ReturnType<typeof Endpoints.GUILD_INTEGRATIONS>}/{integration_id}`;
+    GUILD_INTEGRATIONS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/integrations`;
+    GUILD_MEMBER: (guildId: string, memberId: string) => `${ReturnType<typeof Endpoints.GUILD_MEMBERS>}/{member_id}`;
+    GUILD_MEMBER_ROLE: (guildId: string, memberId: string, roleId: string) => `${ReturnType<typeof Endpoints.GUILD_MEMBER>}/roles/{role_id}`;
+    GUILD_MEMBERS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/members`;
+    GUILD_MEMBERS_SEARCH: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD_MEMBERS>}/search`;
+    GUILD_MESSAGES_SEARCH: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/messages/search`;
+    GUILD_PREVIEW: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/preview`;
+    GUILD_PRUNE: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/prune`;
+    GUILD_ROLE: (guildId: string, roleId: string) => `${ReturnType<typeof Endpoints.GUILD_ROLES>}/{role_id}`;
+    GUILD_ROLES: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/roles`;
+    GUILD_SCHEDULED_EVENTS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/scheduled-events`;
+    GUILD_SCHEDULED_EVENT: (guildId: string, eventId: string) => `${ReturnType<typeof Endpoints.GUILD_SCHEDULED_EVENTS>}/{event_id}`;
+    GUILD_SCHEDULED_EVENT_USERS: (guildId: string, eventId: string) => `${ReturnType<typeof Endpoints.GUILD_SCHEDULED_EVENT>}/users`;
+    GUILD_STICKER: (guildId: string, stickerId: string) => `${ReturnType<typeof Endpoints.GUILD_STICKERS>}/{sticker_id}`;
+    GUILD_STICKERS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/stickers`;
+    GUILD_TEMPLATE: (guildId: string, code: string) => `${ReturnType<typeof Endpoints.GUILD_TEMPLATES>}/{code}`;
+    GUILD_THREADS_ACTIVE: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/threads/active`;
+    GUILD_TEMPLATES: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/templates`;
+    GUILD_VANITY: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/vanity-url`;
+    GUILD_VOICE_REGIONS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/regions`;
+    GUILD_VOICE_STATE_USER: (guildId: string, memberId: string) => `${ReturnType<typeof Endpoints.GUILD>}/voice-states/{member_id}`;
+    GUILD_WEBHOOKS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/webhooks`;
+    GUILD_WELCOME_SCREEN: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/welcome-screen`;
+    GUILD_WIDGET: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/widget.json`;
+    GUILD_WIDGET_SETTINGS: (guildId: string) => `${ReturnType<typeof Endpoints.GUILD>}/widget`;
+    GUILDS: "/guilds";
+    INTERACTION_CALLBACK: (interactionId: string, token: string) => "/interactions/{interaction_id}/{token}/callback";
+    INVITES: (inviteId: string) => "/invites/{invite_id}";
+    INVITE_TARGET_USERS: (inviteId: string) => `${ReturnType<typeof Endpoints.INVITES>}/target-users`;
+    INVITE_TARGET_USERS_JOB_STATUS: (inviteId: string) => `${ReturnType<typeof Endpoints.INVITE_TARGET_USERS>}/job-status`;
+    OAUTH2_APPLICATION: (appId: string) => "/oauth2/applications/{app_id}";
+    OAUTH2_TOKEN: "/api/oauth2/token";
+    POLL_ANSWER: (chanId: string, msgId: string, answerId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/polls/{message_id}/answers/{answer_id}`;
+    POLL_EXPIRE: (chanId: string, msgId: string) => `${ReturnType<typeof Endpoints.CHANNEL>}/polls/{message_id}/expire`;
+    SKU_SUBSCRIPTIONS: (skuId: string) => "/skus/{sku_id}/subscriptions";
+    SKU_SUBSCRIPTION: (skuId: string, subscriptionId: string) => `${ReturnType<typeof Endpoints.SKU_SUBSCRIPTIONS>}/{subscription_id}`;
+    STAGE_INSTANCE_CHANNEL: (chanId: string) => `${typeof Endpoints.STAGE_INSTANCES}/{channel_id}`;
+    STAGE_INSTANCES: "/stage-instances";
+    STICKER: (stickerId: string) => "/stickers/{sticker_id}";
+    TEMPLATE: (code: string) => "/guilds/templates/{code}";
+    USER: (userId: string) => `${typeof Endpoints.USERS}/{user_id}`;
+    USER_APPLICATION_ROLE_CONNECTION: (userId: string, appId: string) => `${ReturnType<typeof Endpoints.USER>}/applications/{app_id}/role-connection`;
+    USER_CHANNELS: (userId: string) => `${ReturnType<typeof Endpoints.USER>}/channels`;
+    USER_CONNECTIONS: (userId: string) => `${ReturnType<typeof Endpoints.USER>}/connections`;
+    USER_GUILD: (userId: string, guildId: string) => `${ReturnType<typeof Endpoints.USER_GUILDS>}/{guild_id}`;
+    USER_GUILDS: (userId: string) => `${ReturnType<typeof Endpoints.USER>}/guilds`;
+    USER_GUILD_VOICE_STATE: (guildId: string, userId: string) => `${ReturnType<typeof Endpoints.GUILD>}/voice-states/{user_id}`;
+    USERS: "/users";
+    VOICE_REGIONS: "/voice/regions";
+    WEBHOOK: (hookId: string) => "/webhooks/{hook_id}";
+    WEBHOOK_TOKEN: (hookId: string, token: string) => `${ReturnType<typeof Endpoints.WEBHOOK>}/{token}`;
+    WEBHOOK_TOKEN_GITHUB: (hookId: string, token: string) => `${ReturnType<typeof Endpoints.WEBHOOK_TOKEN>}/github`;
+    WEBHOOK_TOKEN_MESSAGE: (hookId: string, token: string, msgId: string) => `${ReturnType<typeof Endpoints.WEBHOOK_TOKEN>}/messages/{message_id}`;
+    WEBHOOK_TOKEN_SLACK: (hookId: string, token: string) => `${ReturnType<typeof Endpoints.WEBHOOK_TOKEN>}/slack`;
+};
+export = Endpoints;

package/dist/Endpoints.js

@@ -0,0 +1,121 @@
+"use strict";
+const Constants = require("./Constants");
+/**
+ * Mostly taken from https://github.com/abalabahaha/eris/blob/master/lib/rest/Endpoints.js
+ *
+ * Removed User-only endpoints
+ */
+const Endpoints = {
+    BASE_URL: "/api/v" + Constants.REST_API_VERSION,
+    BASE_HOST: "https://discord.com",
+    CDN_URL: "https://cdn.discordapp.com",
+    APPLICATION_COMMAND: (appId, cmdId) => `${Endpoints.APPLICATION_COMMANDS(appId)}/${cmdId}`,
+    APPLICATION_COMMANDS: (appId) => `/applications/${appId}/commands`,
+    APPLICATION_EMOJI: (appId, emojiId) => `${Endpoints.APPLICATION_EMOJIS(appId)}/${emojiId}`,
+    APPLICATION_EMOJIS: (appId) => `/applications/${appId}/emojis`,
+    APPLICATION_ENTITLEMENT: (appId, entitlementId) => `${Endpoints.APPLICATION_ENTITLEMENTS(appId)}/${entitlementId}`,
+    APPLICATION_ENTITLEMENT_CONSUME: (appId, entitlementId) => `${Endpoints.APPLICATION_ENTITLEMENT(appId, entitlementId)}/consume`,
+    APPLICATION_ENTITLEMENTS: (appId) => `/applications/${appId}/entitlements`,
+    APPLICATION_GUILD_COMMANDS_PERMISSIONS: (appId, guildId) => `${Endpoints.APPLICATION_GUILD_COMMANDS(appId, guildId)}/permissions`,
+    APPLICATION_GUILD_COMMAND_PERMISSIONS: (appId, guildId, cmdId) => `${Endpoints.APPLICATION_GUILD_COMMAND(appId, guildId, cmdId)}/permissions`,
+    APPLICATION_GUILD_COMMAND: (appId, guildId, cmdId) => `${Endpoints.APPLICATION_GUILD_COMMANDS(appId, guildId)}/${cmdId}`,
+    APPLICATION_GUILD_COMMANDS: (appId, guildId) => `/applications/${appId}/guilds/${guildId}/commands`,
+    APPLICATION_SKUS: (appId) => `/applications/${appId}/skus`,
+    ATTACHMENTS_REFRESH_URLS: "/attachments/refresh-urls",
+    CHANNEL: (chanId) => `${Endpoints.CHANNELS}/${chanId}`,
+    CHANNEL_ATTACHMENTS: (chanId) => `${Endpoints.CHANNEL(chanId)}/attachments`,
+    CHANNEL_BULK_DELETE: (chanId) => `${Endpoints.CHANNEL_MESSAGES(chanId)}/bulk-delete`,
+    CHANNEL_FOLLOWERS: (chanId) => `${Endpoints.CHANNEL(chanId)}/followers`,
+    CHANNEL_INVITES: (chanId) => `${Endpoints.CHANNEL(chanId)}/invites`,
+    CHANNEL_MESSAGE: (chanId, msgId) => `${Endpoints.CHANNEL_MESSAGES(chanId)}/${msgId}`,
+    CHANNEL_MESSAGE_CROSSPOST: (chanId, msgId) => `${Endpoints.CHANNEL_MESSAGE(chanId, msgId)}/crosspost`,
+    CHANNEL_MESSAGE_REACTION: (chanId, msgId, reaction) => `${Endpoints.CHANNEL_MESSAGE_REACTIONS(chanId, msgId)}/${reaction}`,
+    CHANNEL_MESSAGE_REACTION_USER: (chanId, msgId, reaction, userId) => `${Endpoints.CHANNEL_MESSAGE_REACTION(chanId, msgId, reaction)}/${userId}`,
+    CHANNEL_MESSAGE_REACTIONS: (chanId, msgId) => `${Endpoints.CHANNEL_MESSAGE(chanId, msgId)}/reactions`,
+    CHANNEL_MESSAGE_THREADS: (chanId, msgId) => `${Endpoints.CHANNEL_MESSAGE(chanId, msgId)}/threads`,
+    CHANNEL_MESSAGES: (chanId) => `${Endpoints.CHANNEL(chanId)}/messages`,
+    CHANNEL_PERMISSION: (chanId, permId) => `${Endpoints.CHANNEL_PERMISSIONS(chanId)}/${permId}`,
+    CHANNEL_PERMISSIONS: (chanId) => `${Endpoints.CHANNEL(chanId)}/permissions`,
+    CHANNEL_PIN: (chanId, msgId) => `${Endpoints.CHANNEL_PINS(chanId)}/${msgId}`,
+    CHANNEL_PINS: (chanId) => `${Endpoints.CHANNEL(chanId)}/messages/pins`,
+    CHANNEL_RECIPIENT: (chanId, userId) => `${Endpoints.CHANNEL(chanId)}/recipients/${userId}`,
+    CHANNEL_THREADS: (chanId) => `${Endpoints.CHANNEL(chanId)}/threads`,
+    CHANNEL_THREAD_MEMBER: (chanId, memberId) => `${Endpoints.CHANNEL_THREAD_MEMBERS(chanId)}/${memberId}`,
+    CHANNEL_THREAD_MEMBERS: (chanId) => `${Endpoints.CHANNEL(chanId)}/thread-members`,
+    CHANNEL_THREADS_ARCHIVED_PRIVATE: (chanId) => `${Endpoints.CHANNEL_THREADS(chanId)}/archived/private`,
+    CHANNEL_THREADS_ARCHIVED_PRIVATE_USER: (chanId) => `${Endpoints.CHANNEL(chanId)}/users/@me/threads/archived/private`,
+    CHANNEL_THREADS_ARCHIVED_PUBLIC: (chanId) => `${Endpoints.CHANNEL_THREADS(chanId)}/archived/public`,
+    CHANNEL_TYPING: (chanId) => `${Endpoints.CHANNEL(chanId)}/typing`,
+    CHANNEL_VOICE_STATUS: (chanId) => `${Endpoints.CHANNEL(chanId)}/voice-status`,
+    CHANNEL_VOICE_HANGOUT: (chanId) => `${Endpoints.CHANNEL(chanId)}/voice-hangout`,
+    CHANNEL_WEBHOOKS: (chanId) => `${Endpoints.CHANNEL(chanId)}/webhooks`,
+    CHANNELS: "/channels",
+    GATEWAY: "/gateway",
+    GATEWAY_BOT: "/gateway/bot",
+    GUILD: (guildId) => `${Endpoints.GUILDS}/${guildId}`,
+    GUILD_AUDIT_LOGS: (guildId) => `${Endpoints.GUILD(guildId)}/audit-logs`,
+    GUILD_AUTO_MOD_RULE: (guildId, ruleId) => `${Endpoints.GUILD_AUTO_MOD_RULES(guildId)}/${ruleId}`,
+    GUILD_AUTO_MOD_RULES: (guildId) => `${Endpoints.GUILD(guildId)}/auto-moderation/rules`,
+    GUILD_BAN: (guildId, memberId) => `${Endpoints.GUILD_BANS(guildId)}/${memberId}`,
+    GUILD_BANS: (guildId) => `${Endpoints.GUILD(guildId)}/bans`,
+    GUILD_CHANNELS: (guildId) => `${Endpoints.GUILD(guildId)}/channels`,
+    GUILD_EMOJI: (guildId, emojiId) => `${Endpoints.GUILD_EMOJIS(guildId)}/${emojiId}`,
+    GUILD_EMOJIS: (guildId) => `${Endpoints.GUILD(guildId)}/emojis`,
+    GUILD_INVITES: (guildId) => `${Endpoints.GUILD(guildId)}/invites`,
+    GUILD_INTEGRATION: (guildId, integrationId) => `${Endpoints.GUILD_INTEGRATIONS(guildId)}/${integrationId}`,
+    GUILD_INTEGRATIONS: (guildId) => `${Endpoints.GUILD(guildId)}/integrations`,
+    GUILD_MEMBER: (guildId, memberId) => `${Endpoints.GUILD_MEMBERS(guildId)}/${memberId}`,
+    GUILD_MEMBER_ROLE: (guildId, memberId, roleId) => `${Endpoints.GUILD_MEMBER(guildId, memberId)}/roles/${roleId}`,
+    GUILD_MEMBERS: (guildId) => `${Endpoints.GUILD(guildId)}/members`,
+    GUILD_MEMBERS_SEARCH: (guildId) => `${Endpoints.GUILD_MEMBERS(guildId)}/search`,
+    GUILD_MESSAGES_SEARCH: (guildId) => `${Endpoints.GUILD(guildId)}/messages/search`,
+    GUILD_PREVIEW: (guildId) => `${Endpoints.GUILD(guildId)}/preview`,
+    GUILD_PRUNE: (guildId) => `${Endpoints.GUILD(guildId)}/prune`,
+    GUILD_ROLE: (guildId, roleId) => `${Endpoints.GUILD_ROLES(guildId)}/${roleId}`,
+    GUILD_ROLES: (guildId) => `${Endpoints.GUILD(guildId)}/roles`,
+    GUILD_SCHEDULED_EVENTS: (guildId) => `${Endpoints.GUILD(guildId)}/scheduled-events`,
+    GUILD_SCHEDULED_EVENT: (guildId, eventId) => `${Endpoints.GUILD_SCHEDULED_EVENTS(guildId)}/${eventId}`,
+    GUILD_SCHEDULED_EVENT_USERS: (guildId, eventId) => `${Endpoints.GUILD_SCHEDULED_EVENT(guildId, eventId)}/users`,
+    GUILD_STICKER: (guildId, stickerId) => `${Endpoints.GUILD_STICKERS(guildId)}/${stickerId}`,
+    GUILD_STICKERS: (guildId) => `${Endpoints.GUILD(guildId)}/stickers`,
+    GUILD_TEMPLATE: (guildId, code) => `${Endpoints.GUILD_TEMPLATES(guildId)}/${code}`,
+    GUILD_THREADS_ACTIVE: (guildId) => `${Endpoints.GUILD(guildId)}/threads/active`,
+    GUILD_TEMPLATES: (guildId) => `${Endpoints.GUILD(guildId)}/templates`,
+    GUILD_VANITY: (guildId) => `${Endpoints.GUILD(guildId)}/vanity-url`,
+    GUILD_VOICE_REGIONS: (guildId) => `${Endpoints.GUILD(guildId)}/regions`,
+    GUILD_VOICE_STATE_USER: (guildId, memberId) => `${Endpoints.GUILD(guildId)}/voice-states/${memberId}`,
+    GUILD_WEBHOOKS: (guildId) => `${Endpoints.GUILD(guildId)}/webhooks`,
+    GUILD_WELCOME_SCREEN: (guildId) => `${Endpoints.GUILD(guildId)}/welcome-screen`,
+    GUILD_WIDGET: (guildId) => `${Endpoints.GUILD(guildId)}/widget.json`,
+    GUILD_WIDGET_SETTINGS: (guildId) => `${Endpoints.GUILD(guildId)}/widget`,
+    GUILDS: "/guilds",
+    INTERACTION_CALLBACK: (interactionId, token) => `/interactions/${interactionId}/${token}/callback`,
+    INVITES: (inviteId) => `/invites/${inviteId}`,
+    INVITE_TARGET_USERS: (inviteId) => `${Endpoints.INVITES(inviteId)}/target-users`,
+    INVITE_TARGET_USERS_JOB_STATUS: (inviteId) => `${Endpoints.INVITE_TARGET_USERS(inviteId)}/job-status`,
+    OAUTH2_APPLICATION: (appId) => `/oauth2/applications/${appId}`,
+    OAUTH2_TOKEN: "/api/oauth2/token",
+    POLL_ANSWER: (chanId, msgId, answerId) => `${Endpoints.CHANNEL(chanId)}/polls/${msgId}/answers/${answerId}`,
+    POLL_EXPIRE: (chanId, msgId) => `${Endpoints.CHANNEL(chanId)}/polls/${msgId}/expire`,
+    SKU_SUBSCRIPTIONS: (skuId) => `/skus/${skuId}/subscriptions`,
+    SKU_SUBSCRIPTION: (skuId, subscriptionId) => `${Endpoints.SKU_SUBSCRIPTIONS(skuId)}/${subscriptionId}`,
+    STAGE_INSTANCE_CHANNEL: (chanId) => `${Endpoints.STAGE_INSTANCES}/${chanId}`,
+    STAGE_INSTANCES: "/stage-instances",
+    STICKER: (stickerId) => `/stickers/${stickerId}`,
+    TEMPLATE: (code) => `/guilds/templates/${code}`,
+    USER: (userId) => `${Endpoints.USERS}/${userId}`,
+    USER_APPLICATION_ROLE_CONNECTION: (userId, appId) => `${Endpoints.USER(userId)}/applications/${appId}/role-connection`,
+    USER_CHANNELS: (userId) => `${Endpoints.USER(userId)}/channels`,
+    USER_CONNECTIONS: (userId) => `${Endpoints.USER(userId)}/connections`,
+    USER_GUILD: (userId, guildId) => `${Endpoints.USER_GUILDS(userId)}/${guildId}`,
+    USER_GUILDS: (userId) => `${Endpoints.USER(userId)}/guilds`,
+    USER_GUILD_VOICE_STATE: (guildId, userId) => `${Endpoints.GUILD(guildId)}/voice-states/${userId}`,
+    USERS: "/users",
+    VOICE_REGIONS: "/voice/regions",
+    WEBHOOK: (hookId) => `/webhooks/${hookId}`,
+    WEBHOOK_TOKEN: (hookId, token) => `${Endpoints.WEBHOOK(hookId)}/${token}`,
+    WEBHOOK_TOKEN_GITHUB: (hookId, token) => `${Endpoints.WEBHOOK_TOKEN(hookId, token)}/github`,
+    WEBHOOK_TOKEN_MESSAGE: (hookId, token, msgId) => `/webhooks/${hookId}/${token}/messages/${msgId}`,
+    WEBHOOK_TOKEN_SLACK: (hookId, token) => `${Endpoints.WEBHOOK_TOKEN(hookId, token)}/slack`,
+};
+module.exports = Endpoints;