snowtransfer 0.18.0 → 0.19.0

package/dist/RequestHandler.js

@@ -0,0 +1,629 @@
+"use strict";
+/* eslint-disable no-async-promise-executor */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandler = exports.Ratelimiter = exports.Bucket = exports.LeakyCounter = exports.IntervalCounter = exports.DiscordAPIError = void 0;
+const fs = require("node:fs");
+const path = require("node:path");
+const node_events_1 = require("node:events");
+const util = require("node:util");
+const nodeCrypto = require("node:crypto");
+const Endpoints = require("./Endpoints");
+const { version } = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), { encoding: "utf8" })); // otherwise, the json was included in the build
+const Constants = require("./Constants");
+const SM = require("./StateMachine");
+// const applicationJSONRegex = /application\/json/;
+const routeRegex = /\/([a-z-]+)\/(?:\d+)/g;
+const reactionsRegex = /\/reactions\/[^/]+/g;
+const reactionsUserRegex = /\/reactions\/:id\/[^/]+/g;
+const webhooksRegex = /^\/webhooks\/(\d+)\/[A-Za-z0-9-_]{64,}/;
+const isMessageEndpointRegex = /\/messages\/:id$/;
+const isGuildChannelsRegex = /\/guilds\/\d+\/channels$/;
+const messagesRegex = /\/messages\/\d+$/;
+const disallowedBodyMethods = new Set(["head", "get", "delete"]);
+/**
+ * @since 0.3.0
+ */
+class DiscordAPIError extends Error {
+    method;
+    path;
+    code;
+    httpStatus;
+    // @ts-expect-error Is assigned by Object.defineProperties
+    request;
+    // @ts-expect-error Is assigned by Object.defineProperties
+    response;
+    constructor(error, request, response) {
+        super();
+        this.name = "DiscordAPIError";
+        this.message = error.message ?? util.inspect(error);
+        this.method = request.method;
+        this.path = request.endpoint;
+        this.code = error.code ?? 4000;
+        this.httpStatus = response.status;
+        Object.defineProperties(this, {
+            request: { enumerable: false, value: request },
+            response: { enumerable: false, value: response },
+        });
+    }
+}
+exports.DiscordAPIError = DiscordAPIError;
+/**
+ * @since 0.17.0
+ */
+class IntervalCounter {
+    limit;
+    reset;
+    /**
+     * Remaining amount of executions during the current timeframe
+     */
+    remaining;
+    firstRequestTime = 0;
+    resetAt = null;
+    id = new Array(3).fill(0).map(() => String.fromCodePoint(Math.floor(Math.random() * 26 + 65))).join("");
+    /**
+     * Create a new base bucket
+     * @param limit Number of functions that may be executed during the timeframe set in reset
+     * @param reset Timeframe in milliseconds until the ratelimit resets after first
+     */
+    constructor(limit, reset) {
+        this.limit = limit;
+        this.reset = reset;
+        this.remaining = limit;
+    }
+    checkReset() {
+        // Check if the counter has refreshed
+        const now = Date.now();
+        // If specific resetAt, use it (ignoring preset reset interval)
+        if (this.resetAt !== null) {
+            if (now > this.resetAt) {
+                this.firstRequestTime = 0;
+                this.remaining = this.limit;
+                this.resetAt = null;
+                if (globalThis.snowtransferDebugLogging)
+                    console.log(`${new Date().toISOString()} [itrv] [${this.id}] informed reset: ${this.remaining}/${this.limit}`);
+            }
+        }
+        // If no specific resetAt, count from first request and reset interval
+        else if (now > this.firstRequestTime + this.reset) {
+            this.firstRequestTime = 0;
+            this.remaining = this.limit;
+            if (globalThis.snowtransferDebugLogging)
+                console.log(`${new Date().toISOString()} [itrv] [${this.id}] predicted reset: ${this.remaining}/${this.limit}`);
+        }
+    }
+    hasReset() {
+        this.checkReset();
+        return this.remaining === this.limit;
+    }
+    canTake() {
+        this.checkReset();
+        return this.remaining > 0;
+    }
+    take() {
+        this.checkReset();
+        if (this.remaining === this.limit)
+            this.firstRequestTime = Date.now();
+        if (this.remaining <= 0)
+            return false;
+        this.remaining--;
+        return true;
+    }
+    timeUntilReset() {
+        const now = Date.now();
+        if (this.resetAt)
+            return Math.max(this.resetAt - now + 1, 0);
+        else
+            return Math.max(this.firstRequestTime + this.reset - Date.now() + 1, 0);
+    }
+    // update the firstRequestTime to represent the *response* time to avoid getting fucked by slight network latency inconsistencies after a bucket refresh
+    responseReceived() {
+        if (this.remaining === this.limit - 1 && this.firstRequestTime)
+            this.firstRequestTime = Date.now();
+    }
+    applyCount(limit, remaining, resetAfter) {
+        if (limit != null)
+            this.limit = limit;
+        this.remaining = remaining;
+        this.resetAt = Date.now() + resetAfter;
+    }
+}
+exports.IntervalCounter = IntervalCounter;
+/**
+ * @since 0.17.0
+ */
+class LeakyCounter {
+    limit;
+    /**
+     * Remaining amount of executions during the current timeframe
+     */
+    remaining;
+    resetAt = null;
+    id = new Array(3).fill(0).map(() => String.fromCodePoint(Math.floor(Math.random() * 26 + 65))).join("");
+    /**
+     * Create a new base bucket
+     * @param limit Number of functions that may be executed until some are reset
+     */
+    constructor(limit) {
+        this.limit = limit;
+        this.remaining = limit;
+    }
+    checkReset() {
+        // Check if the counter has refreshed
+        const now = Date.now();
+        if (this.resetAt && now > this.resetAt) {
+            this.remaining = Math.min(this.limit, this.remaining + 1); // only restore one when it resets
+            this.resetAt = null;
+            if (globalThis.snowtransferDebugLogging)
+                console.log(`${new Date().toISOString()} [leak] [${this.id}] restore one: ${this.remaining}/${this.limit}`);
+        }
+    }
+    hasReset() {
+        this.checkReset();
+        return this.remaining === this.limit;
+    }
+    canTake() {
+        this.checkReset();
+        return this.remaining > 0;
+    }
+    take() {
+        this.checkReset();
+        if (globalThis.snowtransferDebugLogging)
+            console.log(`${new Date().toISOString()} [leak] [${this.id}] took: ${this.remaining - 1} left`);
+        if (this.remaining <= 0)
+            return false;
+        this.remaining--;
+        return true;
+    }
+    timeUntilReset() {
+        const now = Date.now();
+        if (this.resetAt)
+            return Math.max(this.resetAt - now + 1, 0);
+        else
+            return 0;
+    }
+    responseReceived() { }
+    applyCount(limit, remaining, resetAfter) {
+        if (limit != null)
+            this.limit = limit;
+        this.remaining = remaining;
+        this.resetAt = Date.now() + resetAfter;
+        if (globalThis.snowtransferDebugLogging)
+            console.log(`${new Date().toISOString()} [leak] [${this.id}] applied: ${remaining}/${limit} - wait another ${resetAfter}`);
+    }
+}
+exports.LeakyCounter = LeakyCounter;
+/**
+ * Bucket used for saving ratelimits
+ * @since 0.1.0
+ */
+class Bucket {
+    /** Tracks the state this bucket is in (blocked, running, waiting, etc) and what operations are allowed. */
+    sm = new SM("ready");
+    /** Wrapped functions which always resolve (not reject) after the original function has completed and resolved. The original function may manipulate rate limit buckets in that time before it resolves. */
+    calls = [];
+    /** The backing counters of the bucket that determine how many functions can be consumed in a timeframe. */
+    counters = [];
+    pauseRequested = false;
+    /**
+     * Create a new bucket
+     */
+    constructor(counters) {
+        this.counters = counters;
+        // nothing to do, nothing waiting for, the next request will be sent straight away
+        this.sm.defineState("ready", {
+            onEnter: [],
+            onLeave: [],
+            transitions: new Map([
+                ["enqueue", {
+                        destination: "check"
+                    }],
+                ["pause", {
+                        destination: "paused"
+                    }]
+            ])
+        });
+        // trying to send a request, but should first check if there are any requests etc
+        this.sm.defineState("check", {
+            onEnter: [
+                () => {
+                    if (this.pauseRequested) {
+                        return this.sm.doTransition("pause");
+                    }
+                    if (!this.counters.every(c => c.canTake())) {
+                        return this.sm.doTransition("cooldown");
+                    }
+                    if (this.calls.length) {
+                        return this.sm.doTransition("run");
+                    }
+                    return this.sm.doTransition("empty");
+                }
+            ],
+            onLeave: [],
+            transitions: new Map([
+                ["pause", {
+                        destination: "paused"
+                    }],
+                ["cooldown", {
+                        destination: "cooldown"
+                    }],
+                ["run", {
+                        destination: "running"
+                    }],
+                ["empty", {
+                        destination: "ready"
+                    }]
+            ])
+        });
+        // a request is in progress, can't do anything else until it gets back (the bucket is sequential)
+        this.sm.defineState("running", {
+            onEnter: [
+                () => {
+                    // Take one from each counter
+                    this.counters.forEach(c => c.take());
+                    // Dequeue and run
+                    const cb = this.calls.shift();
+                    cb().then(() => {
+                        this.sm.doTransition("complete");
+                    });
+                }
+            ],
+            onLeave: [],
+            transitions: new Map([
+                ["complete", {
+                        destination: "check"
+                    }]
+            ])
+        });
+        // can't send more requests, waiting for rate limit reset. may or may not have pending requests
+        this.sm.defineState("cooldown", {
+            onEnter: [
+                () => {
+                    const blocked = this.counters.filter(c => !c.canTake());
+                    this.sm.doTransitionLater("reset", Math.max(...blocked.map(c => c.timeUntilReset()), 1));
+                }
+            ],
+            onLeave: [],
+            transitions: new Map([
+                ["reset", {
+                        destination: "check"
+                    }]
+            ])
+        });
+        // user has requested nothing to be sent for now
+        this.sm.defineState("paused", {
+            onEnter: [],
+            onLeave: [
+                () => {
+                    this.pauseRequested = false;
+                }
+            ],
+            transitions: new Map([
+                ["resume", {
+                        destination: "check"
+                    }]
+            ])
+        });
+        this.sm.freeze();
+    }
+    /**
+     * Queue a function to be executed
+     * @since 0.12.0
+     * @param fn function to be executed
+     * @returns Result of the function if any
+     */
+    enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.calls.push(() => {
+                return fn(this).then(resolve).catch(reject);
+            });
+            if (this.sm.currentStateName === "ready")
+                this.sm.doTransition("enqueue");
+        });
+    }
+    /**
+     * Pause the bucket from consuming more functions until resumed
+     * @since 0.16.0
+     */
+    pause() {
+        this.pauseRequested = true;
+        if (this.sm.currentStateName === "ready")
+            this.sm.doTransition("pause");
+    }
+    /**
+     * If the bucket is paused, resume it
+     * @since 0.16.0
+     */
+    resume() {
+        this.pauseRequested = false;
+        if (this.sm.currentStateName !== "paused")
+            return;
+        this.sm.doTransition("resume");
+    }
+    /**
+     * Clear the current queue of events to be sent
+     * @since 0.1.0
+     */
+    dropQueue() {
+        this.calls.length = 0;
+    }
+}
+exports.Bucket = Bucket;
+/**
+ * Ratelimiter used for handling the ratelimits imposed by the rest api
+ * @since 0.1.0
+ */
+class Ratelimiter {
+    /**
+     * A Map of Buckets keyed by route keys that store rate limit info
+     */
+    buckets = new Map();
+    /**
+     * The bucket that limits how many requests per second you can make globally
+     */
+    globalBucket = new Bucket([new IntervalCounter(Constants.GLOBAL_REQUESTS_PER_SECOND, 1000)]);
+    /**
+     * If you're being globally rate limited
+     */
+    get global() {
+        return !this.globalBucket.counters[0].canTake();
+    }
+    constructor() {
+        setInterval(() => {
+            for (const [key, value] of this.buckets.entries()) {
+                const counter = value.counters[0];
+                if (value.sm.currentStateName === "ready" && value.calls.length === 0 && counter.hasReset())
+                    this.buckets.delete(key);
+            }
+        }, 1 * 60 * 60 * 1000).unref();
+    }
+    /**
+     * Returns a key for saving ratelimits for routes
+     * (Taken from https://github.com/abalabahaha/eris/blob/master/lib/rest/RequestHandler.js) -> I luv u abal <3
+     * @since 0.1.0
+     * @param url url to reduce to a key something like /channels/266277541646434305/messages/266277541646434305/
+     * @param method method of the request, usual http methods like get, etc.
+     * @returns reduced url: /channels/266277541646434305/messages/:id/
+     */
+    routify(url, method) {
+        let route = url.replaceAll(routeRegex, function (match, p) {
+            return p === "channels" || p === "guilds" || p === "webhooks" ? match : `/${p}/:id`;
+        }).replaceAll(reactionsRegex, "/reactions/:id").replaceAll(reactionsUserRegex, "/reactions/:id/:userId").replace(webhooksRegex, "/webhooks/$1/:token");
+        if (method === "DELETE" && isMessageEndpointRegex.test(route))
+            route = method + route;
+        else if (method === "GET" && isGuildChannelsRegex.test(route))
+            route = "/guilds/:id/channels";
+        if (method === "PUT" || method === "DELETE") {
+            const index = route.indexOf("/reactions");
+            if (index !== -1)
+                route = "MODIFY" + route.slice(0, index + 10);
+        }
+        return route;
+    }
+    /**
+     * Choose a bucket from the route and enqueue a rest call in it
+     * @since 0.1.0
+     * @param fn function to call once the ratelimit is ready
+     * @param url Endpoint of the request
+     * @param method Http method used by the request
+     */
+    queue(fn, url, method) {
+        const routeKey = this.routify(url, method);
+        let bucket = this.buckets.get(routeKey);
+        if (!bucket) {
+            if (method === "DELETE" && messagesRegex.test(url)) {
+                bucket = new Bucket([new LeakyCounter(1), new IntervalCounter(5, 5000), this.globalBucket.counters[0]]);
+            }
+            else
+                bucket = new Bucket([new LeakyCounter(1), this.globalBucket.counters[0]]);
+            this.buckets.set(routeKey, bucket);
+        }
+        return bucket.enqueue(fn);
+    }
+    /**
+     * Set if this Ratelimiter is hitting a global ratelimit for `ms` duration
+     * @since 0.12.0
+     * @param ms How long in milliseconds this Ratelimiter is globally ratelimited for
+     */
+    setGlobal(ms) {
+        this.globalBucket.counters[0].applyCount(Constants.GLOBAL_REQUESTS_PER_SECOND, 0, ms);
+    }
+}
+exports.Ratelimiter = Ratelimiter;
+/**
+ * Request Handler class
+ * @since 0.1.0
+ */
+class RequestHandler extends node_events_1.EventEmitter {
+    ratelimiter;
+    options;
+    latency;
+    apiURL;
+    /**
+     * Create a new request handler
+     * @param ratelimiter ratelimiter to use for ratelimiting requests
+     * @param options options
+     */
+    constructor(ratelimiter, options) {
+        super();
+        this.ratelimiter = ratelimiter;
+        this.options = {
+            baseHost: options?.baseHost ?? Endpoints.BASE_HOST,
+            baseURL: options?.baseURL ?? Endpoints.BASE_URL,
+            bypassBuckets: options?.bypassBuckets ?? false,
+            retryFailed: options?.retryFailed ?? false,
+            retryLimit: options?.retryLimit ?? Constants.DEFAULT_RETRY_LIMIT,
+            headers: {
+                "User-Agent": `Discordbot (https://github.com/DasWolke/SnowTransfer, ${version}) Node.js/${process.version}`
+            },
+            fetch: options?.fetch ?? fetch
+        };
+        if (options?.token)
+            this.options.headers.Authorization = options.token;
+        this.apiURL = this.options.baseHost + this.options.baseURL;
+        this.latency = 500;
+    }
+    request(endpoint, params = {}, method, dataType, data, extraHeaders, retries = this.options.retryLimit, rawResponse = false) {
+        const stack = new Error("SnowTransfer dummy Error to capture before processTicksAndRejections").stack;
+        return new Promise(async (resolve, reject) => {
+            const fn = async (bkt) => {
+                const reqId = nodeCrypto.randomBytes(20).toString("hex");
+                try {
+                    const request = { endpoint, method: method.toUpperCase(), dataType, data: data ?? {} };
+                    this.emit("request", reqId, request);
+                    const before = Date.now();
+                    let response;
+                    switch (dataType) {
+                        case "json":
+                            response = await this._request(endpoint, params, method, data, extraHeaders);
+                            break;
+                        case "multipart":
+                            if (!data)
+                                throw new Error("No multipart data");
+                            response = await this._multiPartRequest(endpoint, params, method, data, extraHeaders);
+                            break;
+                        default:
+                            throw new Error("Forbidden dataType. Use json or multipart or ensure multipart has FormData");
+                    }
+                    this.latency = Date.now() - before;
+                    bkt?.counters.forEach(c => c.responseReceived());
+                    if (bkt)
+                        this._applyRatelimitHeaders(bkt, response.headers);
+                    if (response.status && !Constants.OK_STATUS_CODES.has(response.status) && response.status !== 429) {
+                        if (this.options.retryFailed && !Constants.DO_NOT_RETRY_STATUS_CODES.has(response.status) && retries !== 0)
+                            return resolve(this.request(endpoint, params, method, dataType, data, extraHeaders, retries - 1, rawResponse ? true : undefined));
+                        throw new DiscordAPIError(parseErrorBody(await response.text()), request, response);
+                    }
+                    if (response.status === 429) {
+                        const b = await response.json(); // Discord says it will be a JSON, so if there's an error, sucks
+                        if (b.global)
+                            this.ratelimiter.setGlobal(b.retry_after * 1000);
+                        if (globalThis.snowtransferDebugLogging)
+                            console.log(`${new Date().toISOString()} [rate] [${bkt?.counters[0].id}] !! 429 - guess there was 0 remaining, wait another ${b.retry_after * 1000} (route: ${this.ratelimiter.routify(endpoint, method.toUpperCase())})`);
+                        this.emit("rateLimit", {
+                            method: method.toUpperCase(),
+                            path: endpoint,
+                            route: this.ratelimiter.routify(endpoint, method.toUpperCase())
+                        });
+                        if (this.options.retryFailed && retries !== 0)
+                            return resolve(this.request(endpoint, params, method, dataType, data, extraHeaders, 0, rawResponse ? true : undefined));
+                        throw new DiscordAPIError({ message: b.message, code: b.code ?? 429 }, request, response);
+                    }
+                    this.emit("done", reqId, response, request);
+                    if (rawResponse)
+                        return resolve(response);
+                    if (response.body) {
+                        let b;
+                        try {
+                            b = await response.json();
+                        }
+                        catch {
+                            return resolve(undefined);
+                        }
+                        return resolve(b);
+                    }
+                    else
+                        return resolve(undefined);
+                }
+                catch (error) {
+                    if (error?.stack)
+                        error.stack = error.stack + `\n${stack.split("\n").slice(1).join("\n")}`;
+                    this.emit("requestError", reqId, error);
+                    return reject(error);
+                }
+            };
+            if (this.options.bypassBuckets)
+                fn();
+            else
+                this.ratelimiter.queue(fn, endpoint, method.toUpperCase());
+        });
+    }
+    /**
+     * Apply the received ratelimit headers to the ratelimit bucket
+     * @since 0.1.0
+     * @param bkt Ratelimit bucket to apply the headers to
+     * @param headers Http headers received from discord
+     */
+    _applyRatelimitHeaders(bkt, headers) {
+        const remaining = headers.get("x-ratelimit-remaining");
+        const limit = headers.get("x-ratelimit-limit");
+        const resetAfter = headers.get("x-ratelimit-reset-after");
+        const isGlobal = headers.get("x-ratelimit-global");
+        if (remaining === null && !bkt.counters[0].canTake() && !isGlobal) {
+            // have to reset it now, or it'll never reset again
+            bkt.counters[0].applyCount(null, 1, 0);
+        }
+        if (remaining && limit && resetAfter && !isGlobal) {
+            bkt.counters[0].applyCount(Number.parseInt(limit), Number.parseInt(remaining), Number.parseFloat(resetAfter) * 1000);
+        }
+    }
+    /**
+     * Execute a normal json request
+     * @since 0.1.0
+     * @param endpoint Endpoint to use
+     * @param params URL query parameters to add on to the URL
+     * @param data Data to send
+     * @returns Result of the request
+     */
+    async _request(endpoint, params = {}, method, data, extraHeaders) {
+        const headers = { ...this.options.headers, ...extraHeaders };
+        let body = undefined;
+        if (data != null && !disallowedBodyMethods.has(method)) {
+            if (typeof data === "object")
+                body = JSON.stringify(data);
+            else
+                body = String(data);
+            headers["Content-Type"] = "application/json";
+        }
+        return this.options.fetch(`${this.apiURL}${endpoint}${appendQuery(params)}`, {
+            method: method.toUpperCase(),
+            headers,
+            body
+        });
+    }
+    /**
+     * Execute a multipart/form-data request
+     * @since 0.1.0
+     * @param endpoint Endpoint to use
+     * @param params URL query parameters to add on to the URL
+     * @param method Http Method to use
+     * @param data data to send
+     * @returns Result of the request
+     */
+    async _multiPartRequest(endpoint, params = {}, method, data, extraHeaders) {
+        const headers = { ...this.options.headers, ...extraHeaders };
+        return this.options.fetch(`${this.apiURL}${endpoint}${appendQuery(params)}`, {
+            method: method.toUpperCase(),
+            headers,
+            body: data
+        });
+    }
+}
+exports.RequestHandler = RequestHandler;
+function appendQuery(query) {
+    const filtered = {};
+    let count = 0;
+    for (const [key, value] of Object.entries(query)) {
+        if (value != undefined) {
+            filtered[key] = value;
+            count++;
+        }
+    }
+    return count > 0 ? `?${new URLSearchParams(filtered).toString()}` : "";
+}
+/**
+ * Try to pull message/code out of a Discord JSON error body so DiscordAPIError.code is usable.
+ * Falls back to the raw text if the body isn't JSON.
+ */
+function parseErrorBody(text) {
+    try {
+        const body = JSON.parse(text);
+        let message = body.message ?? text;
+        // Keep the detailed validation errors visible like the raw text used to be
+        if (body.message && body.errors)
+            message = `${body.message}\n${util.inspect(body.errors, { depth: Infinity })}`;
+        return { message, code: body.code };
+    }
+    catch {
+        return { message: text };
+    }
+}

package/dist/SnowTransfer.d.ts

@@ -0,0 +1,70 @@
+import { Ratelimiter, RequestHandler } from "./RequestHandler";
+import AssetsMethods = require("./methods/Assets");
+import AuditLogMethods = require("./methods/AuditLog");
+import AutoModerationMethods = require("./methods/AutoModeration");
+import BotMethods = require("./methods/Bot");
+import ChannelMethods = require("./methods/Channel");
+import EntitlementMethods = require("./methods/Entitlements");
+import GuildMethods = require("./methods/Guild");
+import GuildScheduledEventMethods = require("./methods/GuildScheduledEvent");
+import GuildTemplateMethods = require("./methods/GuildTemplate");
+import InteractionMethods = require("./methods/Interaction");
+import InviteMethods = require("./methods/Invite");
+import SkuMethods = require("./methods/Sku");
+import StageInstanceMethods = require("./methods/StageInstance");
+import UserMethods = require("./methods/User");
+import VoiceMethods = require("./methods/Voice");
+import WebhookMethods = require("./methods/Webhook");
+import type { SnowTransferOptions } from "./Types";
+/**
+ * @since 0.1.0
+ */
+declare class SnowTransfer {
+    /** Options for this SnowTransfer instance */
+    options: SnowTransferOptions;
+    /** The access token to use for requests. Can be a bot or bearer token */
+    token: string | undefined;
+    /** Methods related to channels */
+    readonly channel: ChannelMethods;
+    /** Helper to execute REST calls */
+    readonly requestHandler: RequestHandler;
+    /** Methods related to users */
+    readonly user: UserMethods;
+    /** Methods related to stickers and emojis */
+    readonly assets: AssetsMethods;
+    /** Methods related to webhooks */
+    readonly webhook: WebhookMethods;
+    /** Methods related to guilds */
+    readonly guild: GuildMethods;
+    /** Methods related to guild scheduled events */
+    readonly guildScheduledEvent: GuildScheduledEventMethods;
+    /** Methods related to guild templates */
+    readonly guildTemplate: GuildTemplateMethods;
+    /** Methods related to application commands/interactions */
+    readonly interaction: InteractionMethods;
+    /** Methods related to invites */
+    readonly invite: InviteMethods;
+    /** Methods related to voice regions */
+    readonly voice: VoiceMethods;
+    /** Methods related to getting gateway connect info */
+    readonly bot: BotMethods;
+    /** Methods related to guild audit logs */
+    readonly auditLog: AuditLogMethods;
+    /** Methods related to guild stage instances */
+    readonly stageInstance: StageInstanceMethods;
+    /** Methods related to guild auto mod */
+    readonly autoMod: AutoModerationMethods;
+    /** Methods related to entitlements */
+    readonly entitlement: EntitlementMethods;
+    /** Methods related to SKUs */
+    readonly sku: SkuMethods;
+    /** Ratelimiter used for handling the ratelimits imposed by the rest api */
+    readonly ratelimiter: Ratelimiter;
+    /**
+     * Create a new Rest Client
+     * @param token Discord Bot token to use
+     * @param options options
+     */
+    constructor(token?: string, options?: Partial<SnowTransferOptions>);
+}
+export = SnowTransfer;