snowtransfer 0.17.7 → 0.18.1

package/dist/methods/Interaction.js

@@ -0,0 +1,359 @@
+"use strict";
+const Endpoints = require("../Endpoints");
+const Constants = require("../Constants");
+const v10_1 = require("discord-api-types/v10");
+/**
+ * Methods for interacting with slash command specific endpoints
+ * @since 0.3.0
+ */
+class InteractionMethods {
+    requestHandler;
+    webhooks;
+    options;
+    /**
+     * Create a new Interaction Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.interaction.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     * @param webhooks WebhookMethods class that handles webhook related stuff
+     */
+    constructor(requestHandler, webhooks, options) {
+        this.requestHandler = requestHandler;
+        this.webhooks = webhooks;
+        this.options = options;
+    }
+    /**
+     * Fetch all global commands for your application
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param withLocalizations Whether or not to include localizations
+     * @returns An Array of [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) objects
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const commands = await client.interaction.getApplicationCommands("appId")
+     */
+    async getApplicationCommands(appId, withLocalizations) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMANDS(appId), { with_localizations: withLocalizations }, "get", "json");
+    }
+    /**
+     * Create a new global command. New global commands will be available in all guilds after 1 hour
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param data The command data
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.createApplicationCommand("appId", { name: "test", description: "testing 1, 2, 3" })
+     */
+    async createApplicationCommand(appId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMANDS(appId), {}, "post", "json", data);
+    }
+    /**
+     * Fetch a global command for your application
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param cmdId The Id of the command
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.getApplicationCommand("appId", "cmdId")
+     */
+    async getApplicationCommand(appId, cmdId) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMAND(appId, cmdId), {}, "get", "json");
+    }
+    /**
+     * Edit a global command. Updates will be available in all guilds after 1 hour
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param cmdId The Id of the command
+     * @param data The command data
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.editApplicationCommand("appId", "cmdId", { name: "cool", description: "tells you how cool you are" })
+     */
+    async editApplicationCommand(appId, cmdId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMAND(appId, cmdId), {}, "patch", "json", data);
+    }
+    /**
+     * Deletes a global command
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param cmdId The Id of the command
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.interaction.deleteApplicationCommand("appId", "cmdId")
+     */
+    async deleteApplicationCommand(appId, cmdId) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMAND(appId, cmdId), {}, "delete", "json");
+    }
+    /**
+     * Takes a list of application commands, overwriting existing commands that are registered globally for this application.
+     * Updates will be available in all guilds after 1 hour
+     * @since 0.18.0
+     * @param appId The Id of the application
+     * @param data Array of commands
+     * @returns An Array of [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) objects
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const commands = await client.interaction.editApplicationCommands("appId", [{ name: "test", description: "testing 1, 2, 3" }])
+     */
+    async editApplicationCommands(appId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_COMMANDS(appId), {}, "put", "json", data);
+    }
+    /**
+     * Fetch all of the guild commands for your application for a specific guild.
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param withLocalizations Whether or not to include localizations
+     * @returns An Array of [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) objects
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const commands = await client.interaction.getGuildCommands("appId", "guildId", true)
+     */
+    async getGuildApplicationCommands(appId, guildId, withLocalizations) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMANDS(appId, guildId), { with_localizations: withLocalizations }, "get", "json");
+    }
+    /**
+     * Create a new guild command. New guild commands will be available in the guild immediately.
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param data Command data
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.createGuildApplicationCommand("appId", "guildId", { name: "test", description: "testing 1, 2, 3" })
+     */
+    async createGuildApplicationCommand(appId, guildId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMANDS(appId, guildId), {}, "post", "json", data);
+    }
+    /**
+     * Fetch a guild command for your application
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param cmdId The Id of the command
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.getGuildApplicationCommand("appId", "guildId", "cmdId")
+     */
+    async getGuildApplicationCommand(appId, guildId, cmdId) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMAND(appId, guildId, cmdId), {}, "get", "json");
+    }
+    /**
+     * Edit a guild command. Updates for guild commands will be available immediately.
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param cmdId The Id of the command
+     * @param data New command data
+     * @returns An [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const command = await client.interaction.editGuildApplicationCommand("appId", "guildId", "cmdId", { name: "coolest", description: "tells you that you are the coolest" })
+     */
+    async editGuildApplicationCommand(appId, guildId, cmdId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMAND(appId, guildId, cmdId), {}, "patch", "json", data);
+    }
+    /**
+     * Delete a guild command
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param cmdId The Id of the command
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * client.interaction.deleteGuildApplicationCommand("appId", "guildId", "cmdId")
+     */
+    async deleteGuildApplicationCommand(appId, guildId, cmdId) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMAND(appId, guildId, cmdId), {}, "delete", "json");
+    }
+    /**
+     * Takes a list of application commands, overwriting existing commands for the guild
+     * @since 0.18.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param data Array of commands
+     * @returns An Array of [application command](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure) objects
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const commands = await client.interaction.editGuildApplicationCommands("appId", "guildId", [{ name: "test", description: "testing 1, 2, 3" }])
+     */
+    async editGuildApplicationCommands(appId, guildId, data) {
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMANDS(appId, guildId), {}, "put", "json", data);
+    }
+    async getGuildApplicationCommandPermissions(appId, guildId, cmdId) {
+        if (cmdId)
+            return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMAND_PERMISSIONS(appId, guildId, cmdId), {}, "get", "json");
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMANDS_PERMISSIONS(appId, guildId), {}, "get", "json");
+    }
+    /**
+     * Edits command permissions for a specific command for your application in a guild. You can only add up to 10 permission overwrites for a command.
+     * @since 0.5.0
+     * @param appId The Id of the application
+     * @param guildId The Id of the guild
+     * @param cmdId The Id of the command
+     * @param permissions New application command permissions data
+     * @returns A [guild application command permission](https://discord.com/developers/docs/interactions/application-commands#application-command-permissions-object-guild-application-command-permissions-structure) object
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const permissions = await client.interaction.editGuildApplicationCommandPermissions("appId", "guildId", "cmdId", [{ type: 2, id: "userId", permission: true }])
+     */
+    async editGuildApplicationCommandPermissions(appId, guildId, cmdId, permissions) {
+        const payload = { permissions: permissions };
+        return this.requestHandler.request(Endpoints.APPLICATION_GUILD_COMMAND_PERMISSIONS(appId, guildId, cmdId), {}, "put", "json", payload);
+    }
+    /**
+     * Create a response to an Interaction
+     *
+     * When uploading attachments to respond to message interactions, you must provide the top level files property
+     * which needs to match attachments array length and each element needs to match the same indexes as where their filename is defined (the top level files property gets deleted before it's appended to payload_json).
+     * Should you have a more elegant solution, possibly rewriting the interface with the request handler, please submit a PR/issue.
+     * @since 0.3.0
+     * @param interactionId The Id of the interaction
+     * @param token The token of the interaction
+     * @param data Response data
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * // Respond to a message interaction
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * client.interaction.createInteractionResponse("interactionId", "token", { type: 4, data: { content: "Hello World" } })
+     */
+    async createInteractionResponse(interactionId, token, data) {
+        const payload = Constants.cloneUserInput(data);
+        if ((payload.type === v10_1.InteractionResponseType.ChannelMessageWithSource ||
+            payload.type === v10_1.InteractionResponseType.UpdateMessage) && payload.data)
+            payload.data.allowed_mentions ??= this.options.allowed_mentions;
+        if (payload.files)
+            return this.requestHandler.request(Endpoints.INTERACTION_CALLBACK(interactionId, token), {}, "post", "multipart", await Constants.standardMultipartHandler(payload));
+        else
+            return this.requestHandler.request(Endpoints.INTERACTION_CALLBACK(interactionId, token), {}, "post", "json", payload);
+    }
+    /**
+     * Returns the initial Interaction response
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @returns A [message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * const message = await client.interaction.getOriginalInteractionResponse("appId", "token")
+     */
+    async getOriginalInteractionResponse(appId, token) {
+        return this.webhooks.getWebhookMessage(appId, token, "@original");
+    }
+    /**
+     * Edits the initial Interaction response
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @param data New response data
+     * @returns A [message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * const message = await client.interaction.editOriginalInteractionResponse("appId", "token", { content: "The world said hello back" })
+     */
+    async editOriginalInteractionResponse(appId, token, data) {
+        return this.webhooks.editWebhookMessage(appId, token, "@original", data);
+    }
+    /**
+     * Deletes the initial Interaction response
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * client.interaction.deleteOriginalInteractionResponse("appId", "token")
+     */
+    async deleteOriginalInteractionResponse(appId, token) {
+        return this.webhooks.deleteWebhookMessage(appId, token, "@original");
+    }
+    /**
+     * Create a followup message for an Interaction
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @param data Message data
+     * @returns A [message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * const message = await client.interaction.createFollowupMessage("appId", "token", { content: "The pacer gram fitness test-" })
+     */
+    async createFollowupMessage(appId, token, data) {
+        // wait is always true for interactions and should not be supplied as it will throw an error if the query string is present
+        return this.webhooks.executeWebhook(appId, token, data);
+    }
+    /**
+     * Get a followup message for an Interaction
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @param messageId The Id of the message
+     * @returns A [message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * const message = await client.interaction.getFollowupMessage("appId", "token", "messageId")
+     */
+    async getFollowupMessage(appId, token, messageId) {
+        return this.webhooks.getWebhookMessage(appId, token, messageId);
+    }
+    /**
+     * Edits a followup message for an Interaction
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @param messageId The Id of the message
+     * @param data The new message data
+     * @returns A [message](https://discord.com/developers/docs/resources/channel#message-object) object
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * const message = await client.interaction.editFollowupMessage("appId", "token", "messageId", { content: "-is a multistage aerobic capacity test" })
+     */
+    async editFollowupMessage(appId, token, messageId, data) {
+        return this.webhooks.editWebhookMessage(appId, token, messageId, data);
+    }
+    /**
+     * Deletes a followup message for an Interaction
+     * @since 0.3.0
+     * @param appId The Id of the application
+     * @param token The token of the interaction
+     * @param messageId The Id of the message
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer() // This endpoint does not require a Bot token. The interaction token alone will suffice
+     * client.interaction.deleteFollowupMessage("appId", "token", "messageId")
+     */
+    async deleteFollowupMessage(appId, token, messageId) {
+        return this.webhooks.deleteWebhookMessage(appId, token, messageId);
+    }
+}
+module.exports = InteractionMethods;

package/dist/methods/Invite.d.ts

@@ -0,0 +1,81 @@
+import type { RequestHandler } from "../RequestHandler";
+import type { RESTDeleteAPIInviteResult, RESTGetAPIInviteQuery, RESTGetAPIInviteResult, RESTGetAPIInviteTargetUsersJobStatusResult, RESTPutAPIInviteTargetUsersResult } from "discord-api-types/v10";
+/**
+ * Methods for interacting with invites
+ * @since 0.1.0
+ */
+declare class InviteMethods {
+    readonly requestHandler: RequestHandler;
+    /**
+     * Create a new Invite Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.invite.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler: RequestHandler);
+    /**
+     * Get the invite data on an invite id
+     * @since 0.1.0
+     * @param inviteId Id of the invite
+     * @param options Query params for additional metadata fields
+     * @returns [Invite Object](https://discord.com/developers/docs/resources/invite#invite-object)
+     *
+     * @example
+     * // Gets an invite with approximate_member_count and approximate_presence_count
+     * const client = new SnowTransfer("TOKEN")
+     * const invite = await client.invite.getInvite("inviteId", { with_counts: true })
+     */
+    getInvite(inviteId: string, options?: RESTGetAPIInviteQuery): Promise<RESTGetAPIInviteResult>;
+    /**
+     * Delete an invite
+     * @since 0.1.0
+     * @param inviteId Id of the invite
+     * @param reason Reason for deleting the invite
+     * @returns [Invite Object](https://discord.com/developers/docs/resources/invite#invite-object)
+     *
+     * | Permissions needed | Condition                                     |
+     * |--------------------|-----------------------------------------------|
+     * | MANAGE_CHANNELS    | for invite that belongs to a specific channel |
+     * | MANAGE_GUILD       | delete any invite guild wide                  |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const invite = await client.invite.deleteInvite("inviteId")
+     */
+    deleteInvite(inviteId: string, reason?: string): Promise<RESTDeleteAPIInviteResult>;
+    /**
+     * Gets the users allowed to see and accept an invite
+     * @since 0.17.0
+     * @param inviteId Id of the invite
+     * @returns An Array of user IDs
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const userIds = await client.invite.getInviteTargetUsers("inviteId")
+     */
+    getInviteTargetUsers(inviteId: string): Promise<Array<string>>;
+    /**
+     * Updates the users allowed to see and accept an invite
+     * @since 0.18.0
+     * @param inviteId Id of the invite
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * await client.invite.editInviteTargetUsers("inviteId", someUserArray)
+     */
+    editInviteTargetUsers(inviteId: string, userIds: Array<string>): Promise<RESTPutAPIInviteTargetUsersResult>;
+    /**
+     * Gets the job status on setting target users to an invite
+     * @param inviteId Id of the invite
+     * @returns [Target Users Job Status Object](https://discord.com/developers/docs/resources/invite#get-target-users-job-status-example-response)
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const jobStatus = await client.invite.getInviteTargetUsersJobStatus("inviteId")
+     */
+    getInviteTargetUsersJobStatus(inviteId: string): Promise<RESTGetAPIInviteTargetUsersJobStatusResult>;
+}
+export = InviteMethods;

package/dist/methods/Invite.js

@@ -0,0 +1,107 @@
+"use strict";
+const Endpoints = require("../Endpoints");
+const Constants = require("../Constants");
+/**
+ * Methods for interacting with invites
+ * @since 0.1.0
+ */
+class InviteMethods {
+    requestHandler;
+    /**
+     * Create a new Invite Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.invite.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    /**
+     * Get the invite data on an invite id
+     * @since 0.1.0
+     * @param inviteId Id of the invite
+     * @param options Query params for additional metadata fields
+     * @returns [Invite Object](https://discord.com/developers/docs/resources/invite#invite-object)
+     *
+     * @example
+     * // Gets an invite with approximate_member_count and approximate_presence_count
+     * const client = new SnowTransfer("TOKEN")
+     * const invite = await client.invite.getInvite("inviteId", { with_counts: true })
+     */
+    async getInvite(inviteId, options) {
+        return this.requestHandler.request(Endpoints.INVITES(inviteId), options, "get", "json");
+    }
+    /**
+     * Delete an invite
+     * @since 0.1.0
+     * @param inviteId Id of the invite
+     * @param reason Reason for deleting the invite
+     * @returns [Invite Object](https://discord.com/developers/docs/resources/invite#invite-object)
+     *
+     * | Permissions needed | Condition                                     |
+     * |--------------------|-----------------------------------------------|
+     * | MANAGE_CHANNELS    | for invite that belongs to a specific channel |
+     * | MANAGE_GUILD       | delete any invite guild wide                  |
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const invite = await client.invite.deleteInvite("inviteId")
+     */
+    async deleteInvite(inviteId, reason) {
+        return this.requestHandler.request(Endpoints.INVITES(inviteId), {}, "delete", "json", undefined, Constants.reasonHeader(reason));
+    }
+    /**
+     * Gets the users allowed to see and accept an invite
+     * @since 0.17.0
+     * @param inviteId Id of the invite
+     * @returns An Array of user IDs
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const userIds = await client.invite.getInviteTargetUsers("inviteId")
+     */
+    async getInviteTargetUsers(inviteId) {
+        const response = await this.requestHandler.request(Endpoints.INVITE_TARGET_USERS(inviteId), {}, "get", "json", undefined, undefined, this.requestHandler.options.retryLimit, true);
+        let b;
+        try {
+            b = await response.text();
+        }
+        catch {
+            b = "";
+        }
+        if (!b.length)
+            return [];
+        return b.split("\n").slice(1).map(l => l.replace(",", "").trim()); // first line is the table column names, but only Users exists
+    }
+    /**
+     * Updates the users allowed to see and accept an invite
+     * @since 0.18.0
+     * @param inviteId Id of the invite
+     * @returns Resolves the Promise on successful execution
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * await client.invite.editInviteTargetUsers("inviteId", someUserArray)
+     */
+    async editInviteTargetUsers(inviteId, userIds) {
+        const csv = `Users\n${userIds.join(",\n")},`;
+        const form = new FormData();
+        await Constants.standardAddToFormHandler(form, "target_users_file", csv, "target_users_file.csv");
+        return this.requestHandler.request(Endpoints.INVITE_TARGET_USERS(inviteId), { target_users_file: "target_users_file.csv" }, "put", "multipart", form);
+    }
+    /**
+     * Gets the job status on setting target users to an invite
+     * @param inviteId Id of the invite
+     * @returns [Target Users Job Status Object](https://discord.com/developers/docs/resources/invite#get-target-users-job-status-example-response)
+     *
+     * @example
+     * const client = new SnowTransfer("TOKEN")
+     * const jobStatus = await client.invite.getInviteTargetUsersJobStatus("inviteId")
+     */
+    async getInviteTargetUsersJobStatus(inviteId) {
+        return this.requestHandler.request(Endpoints.INVITE_TARGET_USERS_JOB_STATUS(inviteId), {}, "get", "json");
+    }
+}
+module.exports = InviteMethods;

package/dist/methods/Sku.d.ts

@@ -0,0 +1,58 @@
+import type { RequestHandler } from "../RequestHandler";
+import type { RESTGetAPISKUsResult, RESTGetAPISKUSubscriptionsQuery, RESTGetAPISKUSubscriptionsResult, RESTGetAPISKUSubscriptionResult } from "discord-api-types/v10";
+/**
+ * Methods for interacting with SKUs
+ * @since 0.13.0
+ */
+declare class SkuMethods {
+    readonly requestHandler: RequestHandler;
+    /**
+     * Create a new SKU Method handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.subscription.method` where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler: RequestHandler);
+    /**
+     * Returns all SKUs for a given application.
+     * @since 0.18.0
+     * @param appId Id of the app
+     * @returns Array of [SKU objects](https://discord.com/developers/docs/resources/sku#sku-object)
+     *
+     * @example
+     * // Get all SKUs for an app
+     * const client = new SnowTransfer("TOKEN")
+     * const skus = await client.sku.getSkus("app id")
+     */
+    getSkus(appId: string): Promise<RESTGetAPISKUsResult>;
+    /**
+     * Returns all subscriptions containing the SKU, filtered by user.
+     * @since 0.13.0
+     * @param skuId Id of the SKU
+     * @param options Query data (required with at least `user_id` unless using an OAuth token)
+     * @returns Array of [subscription objects](https://discord.com/developers/docs/resources/subscription#subscription-object)
+     *
+     * @example
+     * // Get all subscriptions for a user
+     * const client = new SnowTransfer("TOKEN")
+     * const filter = { user_id: "user id" }
+     * const subscriptions = await client.sku.getSubscriptions("sku id", filter)
+     */
+    getSubscriptions(skuId: string, options?: RESTGetAPISKUSubscriptionsQuery): Promise<RESTGetAPISKUSubscriptionsResult>;
+    /**
+     * Get a subscription by its ID.
+     * @since 0.13.0
+     * @param skuId Id of the SKU
+     * @param subscriptionId Id of the subscription
+     * @returns A [subscription object](https://discord.com/developers/docs/resources/subscription#subscription-object)
+     *
+     * @example
+     * // Get a subscription for a SKU by Id
+     * const client = new SnowTransfer("TOKEN")
+     * const subscription = await client.sku.getSubscription("sku id", "subscription id")
+     */
+    getSubscription(skuId: string, subscriptionId: string): Promise<RESTGetAPISKUSubscriptionResult>;
+}
+export = SkuMethods;

package/dist/methods/Sku.js

@@ -0,0 +1,66 @@
+"use strict";
+const Endpoints = require("../Endpoints");
+/**
+ * Methods for interacting with SKUs
+ * @since 0.13.0
+ */
+class SkuMethods {
+    requestHandler;
+    /**
+     * Create a new SKU Method handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.subscription.method` where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    /**
+     * Returns all SKUs for a given application.
+     * @since 0.18.0
+     * @param appId Id of the app
+     * @returns Array of [SKU objects](https://discord.com/developers/docs/resources/sku#sku-object)
+     *
+     * @example
+     * // Get all SKUs for an app
+     * const client = new SnowTransfer("TOKEN")
+     * const skus = await client.sku.getSkus("app id")
+     */
+    async getSkus(appId) {
+        return this.requestHandler.request(Endpoints.APPLICATION_SKUS(appId), {}, "get", "json");
+    }
+    /**
+     * Returns all subscriptions containing the SKU, filtered by user.
+     * @since 0.13.0
+     * @param skuId Id of the SKU
+     * @param options Query data (required with at least `user_id` unless using an OAuth token)
+     * @returns Array of [subscription objects](https://discord.com/developers/docs/resources/subscription#subscription-object)
+     *
+     * @example
+     * // Get all subscriptions for a user
+     * const client = new SnowTransfer("TOKEN")
+     * const filter = { user_id: "user id" }
+     * const subscriptions = await client.sku.getSubscriptions("sku id", filter)
+     */
+    async getSubscriptions(skuId, options = {}) {
+        return this.requestHandler.request(Endpoints.SKU_SUBSCRIPTIONS(skuId), options, "get", "json");
+    }
+    /**
+     * Get a subscription by its ID.
+     * @since 0.13.0
+     * @param skuId Id of the SKU
+     * @param subscriptionId Id of the subscription
+     * @returns A [subscription object](https://discord.com/developers/docs/resources/subscription#subscription-object)
+     *
+     * @example
+     * // Get a subscription for a SKU by Id
+     * const client = new SnowTransfer("TOKEN")
+     * const subscription = await client.sku.getSubscription("sku id", "subscription id")
+     */
+    async getSubscription(skuId, subscriptionId) {
+        return this.requestHandler.request(Endpoints.SKU_SUBSCRIPTION(skuId, subscriptionId), {}, "get", "json");
+    }
+}
+module.exports = SkuMethods;