@discordeno/rest 18.0.0-next.1381838 → 18.0.0-next.c271a85

package/dist/restManager.d.ts

@@ -1,19 +1,52 @@
+import { AllowedMentions, BigString, DiscordActivity, DiscordAllowedMentions, DiscordApplication, DiscordApplicationCommand, DiscordApplicationCommandOption, DiscordApplicationCommandOptionChoice, DiscordAttachment, DiscordAuditLogEntry, DiscordAutoModerationActionExecution, DiscordAutoModerationRule, DiscordChannel, DiscordComponent, DiscordCreateApplicationCommand, DiscordEmbed, DiscordEmoji, DiscordGetGatewayBot, DiscordGuild, DiscordGuildApplicationCommandPermissions, DiscordGuildWidget, DiscordGuildWidgetSettings, DiscordIntegrationCreateUpdate, DiscordInteraction, DiscordInteractionDataOption, DiscordInteractionResponse, DiscordInviteCreate, DiscordMember, DiscordMessage, DiscordPresenceUpdate, DiscordRole, DiscordScheduledEvent, DiscordStageInstance, DiscordSticker, DiscordStickerPack, DiscordTeam, DiscordTemplate, DiscordThreadMember, DiscordUser, DiscordVoiceRegion, DiscordVoiceState, DiscordWebhook, DiscordWelcomeScreen, Errors, GetGatewayBot } from '@discordeno/types';
 import { checkRateLimits } from './checkRateLimits.js';
 import { cleanupQueues } from './cleanupQueues.js';
 import { convertRestError } from './convertRestError.js';
+import { InvalidRequestBucket } from './createInvalidRequestBucket.js';
 import { QueueBucket } from './createQueueBucket.js';
 import { createRequestBody } from './createRequestBody.js';
+import * as helpers from './helpers/index.js';
 import { processGlobalQueue } from './processGlobalQueue.js';
 import { processQueue } from './processQueue.js';
 import { processRateLimitedPaths } from './processRateLimitedPaths.js';
 import { processRequest } from './processRequest.js';
 import { processRequestHeaders } from './processRequestHeaders.js';
 import { RestPayload, RestRateLimitedPath, RestRequest } from './rest.js';
+import { routes } from './routes.js';
 import { runMethod } from './runMethod.js';
 import { RestSendRequestOptions, sendRequest } from './sendRequest.js';
 import { simplifyUrl } from './simplifyUrl.js';
-export declare function createRestManager(options: CreateRestManagerOptions): {
-    invalidBucket: import("./createInvalidRequestBucket.js").InvalidRequestBucket;
+import { Activity, Application, ApplicationCommand, ApplicationCommandOption, ApplicationCommandOptionChoice, ApplicationCommandPermission, Attachment, AuditLogEntry, AutoModerationActionExecution, AutoModerationRule, Channel, Component, Embed, Emoji, Guild, GuildWidget, GuildWidgetSettings, Integration, Interaction, InteractionDataOption, Invite, Member, Message, PresenceUpdate, Role, ScheduledEvent, StageInstance, Sticker, StickerPack, Team, Template, ThreadMember, User, VoiceRegions, VoiceState, Webhook, WelcomeScreen } from './transformers/index.js';
+import { CreateApplicationCommand, InteractionResponse } from './types.js';
+export declare function createRestManager(options: CreateRestManagerOptions): RestManager;
+export interface CreateRestManagerOptions {
+    token: string;
+    customUrl?: string;
+    maxRetryCount?: number;
+    version?: number;
+    secretKey?: string;
+    debug?: (text: string) => unknown;
+    checkRateLimits?: typeof checkRateLimits;
+    cleanupQueues?: typeof cleanupQueues;
+    processQueue?: typeof processQueue;
+    processRateLimitedPaths?: typeof processRateLimitedPaths;
+    processRequestHeaders?: typeof processRequestHeaders;
+    processRequest?: typeof processRequest;
+    createRequestBody?: typeof createRequestBody;
+    runMethod?: typeof runMethod;
+    simplifyUrl?: typeof simplifyUrl;
+    processGlobalQueue?: typeof processGlobalQueue;
+    convertRestError?: typeof convertRestError;
+    sendRequest?: typeof sendRequest;
+    fetching?: (options: RestSendRequestOptions) => void;
+    fetched?: (options: RestSendRequestOptions, response: Response) => void;
+    transformers?: Partial<ReturnType<typeof createTransformers>>;
+    helpers?: Partial<Helpers>;
+    applicationId?: bigint;
+    botId?: bigint;
+}
+export interface RestManager {
+    invalidBucket: InvalidRequestBucket;
     version: number;
     token: string;
     maxRetryCount: number;
@@ -23,12 +56,12 @@ export declare function createRestManager(options: CreateRestManagerOptions): {
     processingQueue: boolean;
     processingRateLimitedPaths: boolean;
     globallyRateLimited: boolean;
-    globalQueue: {
+    globalQueue: Array<{
         request: RestRequest;
         payload: RestPayload;
         basicURL: string;
         urlToUse: string;
-    }[];
+    }>;
     globalQueueProcessing: boolean;
     rateLimitedPaths: Map<string, RestRateLimitedPath>;
     debug: (text: string) => unknown;
@@ -46,28 +79,309 @@ export declare function createRestManager(options: CreateRestManagerOptions): {
     sendRequest: typeof sendRequest;
     fetching: (options: RestSendRequestOptions) => void;
     fetched: (options: RestSendRequestOptions, response: Response) => void;
+    transformers: Transformers;
+    constants: {
+        routes: typeof routes;
+        Errors: typeof Errors;
+    };
+    id: bigint;
+    applicationId: bigint;
+    helpers: FinalHelpers;
+}
+export interface Transformers {
+    reverse: {
+        allowedMentions: (rest: RestManager, payload: AllowedMentions) => DiscordAllowedMentions;
+        embed: (rest: RestManager, payload: Embed) => DiscordEmbed;
+        component: (rest: RestManager, payload: Component) => DiscordComponent;
+        activity: (rest: RestManager, payload: Activity) => DiscordActivity;
+        member: (rest: RestManager, payload: Member) => DiscordMember;
+        user: (rest: RestManager, payload: User) => DiscordUser;
+        team: (rest: RestManager, payload: Team) => DiscordTeam;
+        application: (rest: RestManager, payload: Application) => DiscordApplication;
+        snowflake: (snowflake: BigString) => string;
+        createApplicationCommand: (rest: RestManager, payload: CreateApplicationCommand) => DiscordCreateApplicationCommand;
+        applicationCommand: (rest: RestManager, payload: ApplicationCommand) => DiscordApplicationCommand;
+        applicationCommandOption: (rest: RestManager, payload: ApplicationCommandOption) => DiscordApplicationCommandOption;
+        applicationCommandOptionChoice: (rest: RestManager, payload: ApplicationCommandOptionChoice) => DiscordApplicationCommandOptionChoice;
+        interactionResponse: (rest: RestManager, payload: InteractionResponse) => DiscordInteractionResponse;
+        attachment: (rest: RestManager, payload: Attachment) => DiscordAttachment;
+    };
+    snowflake: (snowflake: BigString) => bigint;
+    gatewayBot: (payload: DiscordGetGatewayBot) => GetGatewayBot;
+    automodRule: (rest: RestManager, payload: DiscordAutoModerationRule) => AutoModerationRule;
+    automodActionExecution: (rest: RestManager, payload: DiscordAutoModerationActionExecution) => AutoModerationActionExecution;
+    channel: (rest: RestManager, payload: {
+        channel: DiscordChannel;
+    } & {
+        guildId?: bigint;
+    }) => Channel;
+    guild: (rest: RestManager, payload: {
+        guild: DiscordGuild;
+    } & {
+        shardId: number;
+    }) => Guild;
+    user: (rest: RestManager, payload: DiscordUser) => User;
+    member: (rest: RestManager, payload: DiscordMember, guildId: bigint, userId: bigint) => Member;
+    message: (rest: RestManager, payload: DiscordMessage) => Message;
+    role: (rest: RestManager, payload: {
+        role: DiscordRole;
+    } & {
+        guildId: bigint;
+    }) => Role;
+    voiceState: (rest: RestManager, payload: {
+        voiceState: DiscordVoiceState;
+    } & {
+        guildId: bigint;
+    }) => VoiceState;
+    interaction: (rest: RestManager, payload: DiscordInteraction) => Interaction;
+    interactionDataOptions: (rest: RestManager, payload: DiscordInteractionDataOption) => InteractionDataOption;
+    integration: (rest: RestManager, payload: DiscordIntegrationCreateUpdate) => Integration;
+    invite: (rest: RestManager, invite: DiscordInviteCreate) => Invite;
+    application: (rest: RestManager, payload: DiscordApplication) => Application;
+    team: (rest: RestManager, payload: DiscordTeam) => Team;
+    emoji: (rest: RestManager, payload: DiscordEmoji) => Emoji;
+    activity: (rest: RestManager, payload: DiscordActivity) => Activity;
+    presence: (rest: RestManager, payload: DiscordPresenceUpdate) => PresenceUpdate;
+    attachment: (rest: RestManager, payload: DiscordAttachment) => Attachment;
+    embed: (rest: RestManager, payload: DiscordEmbed) => Embed;
+    component: (rest: RestManager, payload: DiscordComponent) => Component;
+    webhook: (rest: RestManager, payload: DiscordWebhook) => Webhook;
+    auditLogEntry: (rest: RestManager, payload: DiscordAuditLogEntry) => AuditLogEntry;
+    applicationCommand: (rest: RestManager, payload: DiscordApplicationCommand) => ApplicationCommand;
+    applicationCommandOption: (rest: RestManager, payload: DiscordApplicationCommandOption) => ApplicationCommandOption;
+    applicationCommandPermission: (rest: RestManager, payload: DiscordGuildApplicationCommandPermissions) => ApplicationCommandPermission;
+    scheduledEvent: (rest: RestManager, payload: DiscordScheduledEvent) => ScheduledEvent;
+    threadMember: (rest: RestManager, payload: DiscordThreadMember) => ThreadMember;
+    welcomeScreen: (rest: RestManager, payload: DiscordWelcomeScreen) => WelcomeScreen;
+    voiceRegion: (rest: RestManager, payload: DiscordVoiceRegion) => VoiceRegions;
+    widget: (rest: RestManager, payload: DiscordGuildWidget) => GuildWidget;
+    widgetSettings: (rest: RestManager, payload: DiscordGuildWidgetSettings) => GuildWidgetSettings;
+    stageInstance: (rest: RestManager, payload: DiscordStageInstance) => StageInstance;
+    sticker: (rest: RestManager, payload: DiscordSticker) => Sticker;
+    stickerPack: (rest: RestManager, payload: DiscordStickerPack) => StickerPack;
+    applicationCommandOptionChoice: (rest: RestManager, payload: DiscordApplicationCommandOptionChoice) => ApplicationCommandOptionChoice;
+    template: (rest: RestManager, payload: DiscordTemplate) => Template;
+}
+export declare function createTransformers(options: Partial<Transformers>): Transformers;
+export declare const defaultHelpers: {
+    followAnnouncementChannel(rest: RestManager, sourceChannelId: BigString, targetChannelId: BigString): Promise<bigint>;
+    createChannel(rest: RestManager, guildId: BigString, options: helpers.CreateGuildChannel): Promise<Channel>;
+    deleteChannel(rest: RestManager, channelId: BigString, reason?: string | undefined): Promise<void>;
+    deleteChannelPermissionOverride(rest: RestManager, channelId: BigString, overwriteId: BigString, reason?: string | undefined): Promise<void>;
+    editChannel(rest: RestManager, channelId: BigString, options: helpers.ModifyChannel): Promise<Channel>;
+    editChannelPermissionOverrides(rest: RestManager, channelId: BigString, options: helpers.EditChannelPermissionOverridesOptions): Promise<void>;
+    editChannelPositions(rest: RestManager, guildId: BigString, channelPositions: helpers.ModifyGuildChannelPositions[]): Promise<void>;
+    swapChannels: typeof helpers.editChannelPositions;
+    createForumThread(rest: RestManager, channelId: BigString, options: helpers.CreateForumPostWithMessage): Promise<Channel>;
+    getChannel(rest: RestManager, channelId: BigString): Promise<Channel>;
+    getChannelInvites(rest: RestManager, channelId: BigString): Promise<import("@discordeno/utils").Collection<string, helpers.InviteMetadata>>;
+    getChannels(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Channel>>;
+    createStageInstance(rest: RestManager, options: helpers.CreateStageInstance): Promise<StageInstance>;
+    deleteStageInstance(rest: RestManager, channelId: BigString, reason?: string | undefined): Promise<void>;
+    editStageInstance(rest: RestManager, channelId: BigString, data: helpers.EditStageInstanceOptions): Promise<StageInstance>;
+    getStageInstance(rest: RestManager, channelId: BigString): Promise<StageInstance>;
+    addThreadMember(rest: RestManager, channelId: BigString, userId: BigString): Promise<void>;
+    getActiveThreads(rest: RestManager, guildId: BigString): Promise<helpers.ActiveThreads>;
+    getPrivateArchivedThreads(rest: RestManager, channelId: BigString, options?: helpers.ListArchivedThreads | undefined): Promise<helpers.ArchivedThreads>;
+    getPrivateJoinedArchivedThreads(rest: RestManager, channelId: BigString, options?: helpers.ListArchivedThreads | undefined): Promise<helpers.ArchivedThreads>;
+    getPublicArchivedThreads(rest: RestManager, channelId: BigString, options?: helpers.ListArchivedThreads | undefined): Promise<helpers.ArchivedThreads>;
+    getThreadMember(rest: RestManager, channelId: BigString, userId: BigString): Promise<ThreadMember>;
+    getThreadMembers(rest: RestManager, channelId: BigString): Promise<import("@discordeno/utils").Collection<bigint, ThreadMember>>;
+    joinThread(rest: RestManager, channelId: BigString): Promise<void>;
+    leaveThread(rest: RestManager, channelId: BigString): Promise<void>;
+    removeThreadMember(rest: RestManager, channelId: BigString, userId: BigString): Promise<void>;
+    startThreadWithMessage(rest: RestManager, channelId: BigString, messageId: BigString, options: helpers.StartThreadWithMessage): Promise<Channel>;
+    startThreadWithoutMessage(rest: RestManager, channelId: BigString, options: helpers.StartThreadWithoutMessage): Promise<Channel>;
+    triggerTypingIndicator(rest: RestManager, channelId: BigString): Promise<void>;
+    startTyping: typeof helpers.triggerTypingIndicator;
+    createEmoji(rest: RestManager, guildId: BigString, options: helpers.CreateGuildEmoji): Promise<Emoji>;
+    deleteEmoji(rest: RestManager, guildId: BigString, id: BigString, reason?: string | undefined): Promise<void>;
+    editEmoji(rest: RestManager, guildId: BigString, id: BigString, options: helpers.ModifyGuildEmoji): Promise<Emoji>;
+    getEmoji(rest: RestManager, guildId: BigString, emojiId: BigString): Promise<Emoji>;
+    getEmojis(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Emoji>>;
+    getEmojiURL(_rest: RestManager, emojiId: BigString, animated?: boolean): string;
+    createAutomodRule(rest: RestManager, guildId: BigString, options: helpers.CreateAutoModerationRuleOptions): Promise<AutoModerationRule>;
+    deleteAutomodRule(rest: RestManager, guildId: BigString, ruleId: BigString, reason?: string | undefined): Promise<void>;
+    editAutomodRule(rest: RestManager, guildId: BigString, ruleId: BigString, options: Partial<helpers.EditAutoModerationRuleOptions>): Promise<AutoModerationRule>;
+    getAutomodRule(rest: RestManager, guildId: BigString, ruleId: BigString): Promise<AutoModerationRule>;
+    getAutomodRules(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, AutoModerationRule>>;
+    createGuild(rest: RestManager, options: helpers.CreateGuild): Promise<Guild>;
+    deleteGuild(rest: RestManager, guildId: BigString): Promise<void>;
+    editGuild(rest: RestManager, guildId: BigString, options: helpers.ModifyGuild, shardId: number): Promise<Guild>;
+    editGuildMfaLevel(rest: RestManager, guildId: BigString, mfaLevel: import("@discordeno/types").MfaLevels, reason?: string | undefined): Promise<void>;
+    editWelcomeScreen(rest: RestManager, guildId: BigString, options: helpers.ModifyGuildWelcomeScreen): Promise<WelcomeScreen>;
+    createScheduledEvent(rest: RestManager, guildId: BigString, options: helpers.CreateScheduledEvent): Promise<ScheduledEvent>;
+    deleteScheduledEvent(rest: RestManager, guildId: BigString, eventId: BigString): Promise<void>;
+    editScheduledEvent(rest: RestManager, guildId: BigString, eventId: BigString, options: Partial<helpers.EditScheduledEvent>): Promise<ScheduledEvent>;
+    getScheduledEvent(rest: RestManager, guildId: BigString, eventId: BigString, options?: {
+        withUserCount?: boolean | undefined;
+    } | undefined): Promise<ScheduledEvent>;
+    getScheduledEvents(rest: RestManager, guildId: BigString, options?: helpers.GetScheduledEvents | undefined): Promise<import("@discordeno/utils").Collection<bigint, ScheduledEvent>>;
+    getScheduledEventUsers(rest: RestManager, guildId: BigString, eventId: BigString, options?: (helpers.GetScheduledEventUsers & {
+        withMember?: false | undefined;
+    }) | undefined): Promise<import("@discordeno/utils").Collection<bigint, User>>;
+    getScheduledEventUsers(rest: RestManager, guildId: BigString, eventId: BigString, options?: (helpers.GetScheduledEventUsers & {
+        withMember: true;
+    }) | undefined): Promise<import("@discordeno/utils").Collection<bigint, {
+        user: User;
+        member: Member;
+    }>>;
+    getAuditLog(rest: RestManager, guildId: BigString, options?: helpers.GetGuildAuditLog | undefined): Promise<helpers.AuditLog>;
+    getBan(rest: RestManager, guildId: BigString, userId: BigString): Promise<helpers.Ban>;
+    getBans(rest: RestManager, guildId: BigString, options?: helpers.GetBans | undefined): Promise<import("@discordeno/utils").Collection<bigint, helpers.Ban>>;
+    getGuildBannerURL(rest: RestManager, guildId: BigString, options: {
+        banner?: string | bigint | undefined;
+        size?: import("@discordeno/types").ImageSize | undefined;
+        format?: import("@discordeno/types").ImageFormat | undefined;
+    }): string | undefined;
+    getGuildIconURL(rest: RestManager, guildId: BigString, imageHash: BigString | undefined, options?: {
+        size?: import("@discordeno/types").ImageSize | undefined;
+        format?: import("@discordeno/types").ImageFormat | undefined;
+    } | undefined): string | undefined;
+    getGuildPreview(rest: RestManager, guildId: BigString): Promise<helpers.GuildPreview>;
+    getGuildSplashURL(rest: RestManager, guildId: BigString, imageHash: BigString | undefined, options?: {
+        size?: import("@discordeno/types").ImageSize | undefined;
+        format?: import("@discordeno/types").ImageFormat | undefined;
+    } | undefined): string | undefined;
+    getPruneCount(rest: RestManager, guildId: BigString, options?: helpers.GetGuildPruneCountQuery | undefined): Promise<number>;
+    getVanityUrl(rest: RestManager, guildId: BigString): Promise<helpers.VanityUrl>;
+    getWelcomeScreen(rest: RestManager, guildId: BigString): Promise<WelcomeScreen>;
+    deleteIntegration(rest: RestManager, guildId: BigString, integrationId: BigString): Promise<void>;
+    getIntegrations(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Integration>>;
+    createInvite(rest: RestManager, channelId: BigString, options?: helpers.CreateChannelInvite): Promise<helpers.BaseInvite>;
+    deleteInvite(rest: RestManager, inviteCode: string, reason?: string | undefined): Promise<void>;
+    getInvite(rest: RestManager, inviteCode: string, options?: helpers.GetInvite | undefined): Promise<helpers.BaseInvite>;
+    getInvites(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<string, helpers.InviteMetadata>>;
+    leaveGuild(rest: RestManager, guildId: BigString): Promise<void>;
+    editOwnVoiceState(rest: RestManager, guildId: BigString, options: helpers.EditOwnVoiceState): Promise<void>;
+    editUserVoiceState(rest: RestManager, guildId: BigString, options: helpers.EditUserVoiceState): Promise<void>;
+    updateBotVoiceState: typeof helpers.editOwnVoiceState;
+    getAvailableVoiceRegions(rest: RestManager): Promise<import("@discordeno/utils").Collection<string, VoiceRegions>>;
+    getVoiceRegions(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<string, VoiceRegions>>;
+    editWidgetSettings(rest: RestManager, guildId: BigString, enabled: boolean, channelId?: string | null | undefined): Promise<GuildWidgetSettings>;
+    getWidget(rest: RestManager, guildId: BigString): Promise<GuildWidget>;
+    getWidgetImageURL(rest: RestManager, guildId: BigString, options?: helpers.GetGuildWidgetImageQuery | undefined): string;
+    getWidgetSettings(rest: RestManager, guildId: BigString): Promise<GuildWidgetSettings>;
+    createGlobalApplicationCommand(rest: RestManager, command: CreateApplicationCommand): Promise<ApplicationCommand>;
+    createGuildApplicationCommand(rest: RestManager, command: CreateApplicationCommand, guildId: BigString): Promise<ApplicationCommand>;
+    deleteGlobalApplicationCommand(rest: RestManager, commandId: BigString): Promise<void>;
+    deleteGuildApplicationCommand(rest: RestManager, commandId: BigString, guildId: BigString): Promise<void>;
+    editApplicationCommandPermissions(rest: RestManager, guildId: BigString, commandId: BigString, bearerToken: string, options: helpers.ApplicationCommandPermissions[]): Promise<ApplicationCommandPermission>;
+    editGlobalApplicationCommand(rest: RestManager, commandId: BigString, options: CreateApplicationCommand): Promise<ApplicationCommand>;
+    editGuildApplicationCommand(rest: RestManager, commandId: BigString, guildId: BigString, options: CreateApplicationCommand): Promise<ApplicationCommand>;
+    getApplicationCommandPermission(rest: RestManager, guildId: BigString, commandId: BigString): Promise<ApplicationCommandPermission>;
+    getApplicationCommandPermissions(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, ApplicationCommandPermission>>;
+    getGlobalApplicationCommand(rest: RestManager, commandId: BigString): Promise<ApplicationCommand>;
+    getGlobalApplicationCommands(rest: RestManager): Promise<import("@discordeno/utils").Collection<bigint, ApplicationCommand>>;
+    getGuildApplicationCommand(rest: RestManager, commandId: BigString, guildId: BigString): Promise<ApplicationCommand>;
+    getGuildApplicationCommands(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, ApplicationCommand>>;
+    upsertGlobalApplicationCommands(rest: RestManager, commands: CreateApplicationCommand[]): Promise<import("@discordeno/utils").Collection<bigint, ApplicationCommand>>;
+    upsertGuildApplicationCommands(rest: RestManager, guildId: BigString, commands: CreateApplicationCommand[]): Promise<import("@discordeno/utils").Collection<bigint, ApplicationCommand>>;
+    deleteFollowupMessage(rest: RestManager, token: string, messageId: BigString): Promise<void>;
+    deleteOriginalInteractionResponse(rest: RestManager, token: string): Promise<void>;
+    editFollowupMessage(rest: RestManager, token: string, messageId: BigString, options: import("./types.js").InteractionCallbackData): Promise<Message>;
+    editOriginalInteractionResponse(rest: RestManager, token: string, options: import("./types.js").InteractionCallbackData): Promise<Message | undefined>;
+    getFollowupMessage(rest: RestManager, token: string, messageId: BigString): Promise<Message>;
+    getOriginalInteractionResponse(rest: RestManager, token: string): Promise<Message>;
+    sendFollowupMessage(rest: RestManager, token: string, options: InteractionResponse): Promise<Message>;
+    sendInteractionResponse(rest: RestManager, interactionId: BigString, token: string, options: InteractionResponse): Promise<void>;
+    banMember(rest: RestManager, guildId: BigString, userId: BigString, options?: helpers.CreateGuildBan | undefined): Promise<void>;
+    editBotMember(rest: RestManager, guildId: BigString, options: helpers.EditBotMemberOptions): Promise<Member>;
+    editMember(rest: RestManager, guildId: BigString, userId: BigString, options: helpers.ModifyGuildMember): Promise<Member>;
+    getAvatarURL(rest: RestManager, userId: BigString, discriminator: string, options?: {
+        avatar: BigString | undefined;
+        size?: import("@discordeno/types").ImageSize | undefined;
+        format?: import("@discordeno/types").ImageFormat | undefined;
+    } | undefined): string;
+    getDmChannel(rest: RestManager, userId: BigString): Promise<Channel>;
+    getMember(rest: RestManager, guildId: BigString, userId: BigString): Promise<Member>;
+    getMembers(rest: RestManager, guildId: BigString, options: helpers.ListGuildMembers): Promise<import("@discordeno/utils").Collection<bigint, Member>>;
+    kickMember(rest: RestManager, guildId: BigString, userId: BigString, reason?: string | undefined): Promise<void>;
+    pruneMembers(rest: RestManager, guildId: BigString, options: helpers.BeginGuildPrune): Promise<number | undefined>;
+    searchMembers(rest: RestManager, guildId: BigString, query: string, options?: Omit<import("@discordeno/types").SearchMembers, "query"> | undefined): Promise<import("@discordeno/utils").Collection<bigint, Member>>;
+    unbanMember(rest: RestManager, guildId: BigString, userId: BigString): Promise<void>;
+    crosspostMessage(rest: RestManager, channelId: BigString, messageId: BigString): Promise<Message>;
+    publishMessage: typeof helpers.crosspostMessage;
+    deleteMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string | undefined, delayMilliseconds?: number): Promise<void>;
+    deleteMessages(rest: RestManager, channelId: BigString, messageIds: BigString[], reason?: string | undefined): Promise<void>;
+    editMessage(rest: RestManager, channelId: BigString, messageId: BigString, options: helpers.EditMessage): Promise<Message>;
+    getMessage(rest: RestManager, channelId: BigString, messageId: BigString): Promise<Message>;
+    getMessages(rest: RestManager, channelId: BigString, options?: helpers.GetMessagesOptions | undefined): Promise<import("@discordeno/utils").Collection<bigint, Message>>;
+    isGetMessagesAfter(options: helpers.GetMessagesOptions): options is helpers.GetMessagesAfter;
+    isGetMessagesBefore(options: helpers.GetMessagesOptions): options is helpers.GetMessagesBefore;
+    isGetMessagesAround(options: helpers.GetMessagesOptions): options is helpers.GetMessagesAround;
+    isGetMessagesLimit(options: helpers.GetMessagesOptions): options is helpers.GetMessagesLimit;
+    getPinnedMessages(rest: RestManager, channelId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Message>>;
+    pinMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string | undefined): Promise<void>;
+    addReaction(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void>;
+    addReactions(rest: RestManager, channelId: BigString, messageId: BigString, reactions: string[], ordered?: boolean): Promise<void>;
+    deleteOwnReaction(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void>;
+    deleteUserReaction(rest: RestManager, channelId: BigString, messageId: BigString, userId: BigString, reaction: string): Promise<void>;
+    deleteReactionsAll(rest: RestManager, channelId: BigString, messageId: BigString): Promise<void>;
+    deleteReactionsEmoji(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string): Promise<void>;
+    getReactions(rest: RestManager, channelId: BigString, messageId: BigString, reaction: string, options?: helpers.GetReactions | undefined): Promise<import("@discordeno/utils").Collection<bigint, User>>;
+    processReactionString(reaction: string): string;
+    sendMessage(rest: RestManager, channelId: BigString, options: helpers.CreateMessage): Promise<Message>;
+    unpinMessage(rest: RestManager, channelId: BigString, messageId: BigString, reason?: string | undefined): Promise<void>;
+    editBotProfile(rest: RestManager, options: {
+        username?: string | undefined;
+        botAvatarURL?: string | null | undefined;
+    }): Promise<User>;
+    getApplicationInfo(rest: RestManager): Promise<Application>;
+    getGatewayBot(rest: RestManager): Promise<GetGatewayBot>;
+    getNitroStickerPacks(rest: RestManager): Promise<import("@discordeno/utils").Collection<bigint, StickerPack>>;
+    getUser(rest: RestManager, userId: BigString): Promise<User>;
+    addRole(rest: RestManager, guildId: BigString, userId: BigString, roleId: BigString, reason?: string | undefined): Promise<void>;
+    createRole(rest: RestManager, guildId: BigString, options: helpers.CreateGuildRole, reason?: string | undefined): Promise<Role>;
+    deleteRole(rest: RestManager, guildId: BigString, roleId: BigString): Promise<void>;
+    editRole(rest: RestManager, guildId: BigString, roleId: BigString, options: helpers.EditGuildRole): Promise<Role>;
+    modifyRolePositions(rest: RestManager, guildId: BigString, options: helpers.ModifyRolePositions[]): Promise<import("@discordeno/utils").Collection<bigint, Role>>;
+    getRoles(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Role>>;
+    removeRole(rest: RestManager, guildId: BigString, userId: BigString, roleId: BigString, reason?: string | undefined): Promise<void>;
+    createGuildSticker(rest: RestManager, guildId: bigint, options: helpers.CreateGuildStickerOptions): Promise<Sticker>;
+    deleteGuildSticker(rest: RestManager, guildId: bigint, stickerId: bigint, reason?: string | undefined): Promise<void>;
+    editGuildSticker(rest: RestManager, guildId: bigint, stickerId: bigint, options: import("@discordeno/types").AtLeastOne<helpers.EditGuildStickerOptions, {
+        name?: Pick<helpers.EditGuildStickerOptions, "name"> | undefined;
+        description?: Pick<helpers.EditGuildStickerOptions, "description"> | undefined;
+        tags?: Pick<helpers.EditGuildStickerOptions, "tags"> | undefined;
+        reason?: Pick<helpers.EditGuildStickerOptions, "reason"> | undefined;
+    }>): Promise<Sticker>;
+    getGuildSticker(rest: RestManager, guildId: bigint, stickerId: bigint): Promise<Sticker>;
+    getGuildStickers(rest: RestManager, guildId: bigint): Promise<import("@discordeno/utils").Collection<bigint, Sticker>>;
+    getSticker(rest: RestManager, stickerId: bigint): Promise<Sticker>;
+    createGuildTemplate(rest: RestManager, guildId: BigString, options: helpers.CreateTemplate): Promise<Template>;
+    deleteGuildTemplate(rest: RestManager, guildId: BigString, templateCode: string): Promise<void>;
+    editGuildTemplate(rest: RestManager, guildId: BigString, templateCode: string, options: helpers.ModifyGuildTemplate): Promise<Template>;
+    getGuildTemplate(rest: RestManager, templateCode: string): Promise<Template>;
+    getGuildTemplates(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<string, Template>>;
+    syncGuildTemplate(rest: RestManager, guildId: BigString, templateCode: string): Promise<Template>;
+    createWebhook(rest: RestManager, channelId: BigString, options: helpers.CreateWebhook): Promise<Webhook>;
+    deleteWebhook(rest: RestManager, webhookId: BigString, reason?: string | undefined): Promise<void>;
+    deleteWebhookMessage(rest: RestManager, webhookId: BigString, token: string, messageId: BigString, options?: helpers.DeleteWebhookMessageOptions | undefined): Promise<void>;
+    deleteWebhookWithToken(rest: RestManager, webhookId: BigString, token: string): Promise<void>;
+    editOriginalWebhookMessage(rest: RestManager, webhookId: BigString, token: string, options: import("./types.js").InteractionCallbackData & {
+        threadId?: BigString | undefined;
+    }): Promise<Message>;
+    editWebhook(rest: RestManager, webhookId: BigString, options: helpers.ModifyWebhook): Promise<Webhook>;
+    editWebhookMessage(rest: RestManager, webhookId: BigString, token: string, messageId: BigString, options: import("./types.js").InteractionCallbackData & {
+        threadId?: BigString | undefined;
+    }): Promise<Message>;
+    editWebhookWithToken(rest: RestManager, webhookId: BigString, token: string, options: Omit<helpers.ModifyWebhook, "channelId">): Promise<Webhook>;
+    executeWebhook(rest: RestManager, webhookId: BigString, token: string, options: helpers.ExecuteWebhook): Promise<Message | undefined>;
+    sendWebhookMessage: typeof helpers.executeWebhook;
+    getChannelWebhooks(rest: RestManager, channelId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Webhook>>;
+    getGuildWebhooks(rest: RestManager, guildId: BigString): Promise<import("@discordeno/utils").Collection<bigint, Webhook>>;
+    getWebhook(rest: RestManager, webhookId: BigString): Promise<Webhook>;
+    getWebhookMessage(rest: RestManager, webhookId: BigString, token: string, messageId: BigString, options?: helpers.GetWebhookMessageOptions | undefined): Promise<Message>;
+    getWebhookWithToken(rest: RestManager, webhookId: BigString, token: string): Promise<Webhook>;
 };
-export interface CreateRestManagerOptions {
-    token: string;
-    customUrl?: string;
-    maxRetryCount?: number;
-    version?: number;
-    secretKey?: string;
-    debug?: (text: string) => unknown;
-    checkRateLimits?: typeof checkRateLimits;
-    cleanupQueues?: typeof cleanupQueues;
-    processQueue?: typeof processQueue;
-    processRateLimitedPaths?: typeof processRateLimitedPaths;
-    processRequestHeaders?: typeof processRequestHeaders;
-    processRequest?: typeof processRequest;
-    createRequestBody?: typeof createRequestBody;
-    runMethod?: typeof runMethod;
-    simplifyUrl?: typeof simplifyUrl;
-    processGlobalQueue?: typeof processGlobalQueue;
-    convertRestError?: typeof convertRestError;
-    sendRequest?: typeof sendRequest;
-    fetching?: (options: RestSendRequestOptions) => void;
-    fetched?: (options: RestSendRequestOptions, response: Response) => void;
+export type DefaultHelpers = typeof defaultHelpers;
+export interface Helpers extends DefaultHelpers {
 }
-export type RestManager = ReturnType<typeof createRestManager>;
+export declare function createHelpers(rest: RestManager, customHelpers?: Partial<Helpers>): FinalHelpers;
+export declare function createBaseHelpers(options: Partial<Helpers>): DefaultHelpers & Partial<Helpers>;
+export type RemoveFirstFromTuple<T extends any[]> = T['length'] extends 0 ? [] : ((...b: T) => void) extends (a: any, ...b: infer I) => void ? I : [];
+export type FinalHelpers = {
+    [K in keyof Helpers]: (...args: RemoveFirstFromTuple<Parameters<Helpers[K]>>) => ReturnType<Helpers[K]>;
+};
 //# sourceMappingURL=restManager.d.ts.map

package/dist/restManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restManager.d.ts","sourceRoot":"","sources":["../src/restManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,wBAAgB,iBAAiB,CAAE,OAAO,EAAE,wBAAwB;;;;;;;;;;;;iBAmBrD,WAAW;iBACX,WAAW;kBACV,MAAM;kBACN,MAAM;;;;;;;;;;;;;;;;;;;EAqCrB;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IACjC,eAAe,CAAC,EAAE,OAAO,eAAe,CAAA;IACxC,aAAa,CAAC,EAAE,OAAO,aAAa,CAAA;IACpC,YAAY,CAAC,EAAE,OAAO,YAAY,CAAA;IAClC,uBAAuB,CAAC,EAAE,OAAO,uBAAuB,CAAA;IACxD,qBAAqB,CAAC,EAAE,OAAO,qBAAqB,CAAA;IACpD,cAAc,CAAC,EAAE,OAAO,cAAc,CAAA;IACtC,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAA;IAC5C,SAAS,CAAC,EAAE,OAAO,SAAS,CAAA;IAC5B,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;IAChC,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAA;IAC9C,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAA;IAC1C,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;IAChC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACpD,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,EAAE,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAA;CACxE;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"restManager.d.ts","sourceRoot":"","sources":["../src/restManager.ts"],"names":[],"mappings":"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"}

package/dist/restManager.js

@@ -1,2 +1,2 @@
-import{API_VERSION as e,baseEndpoints as s,removeTokenPrefix as t}from"@discordeno/utils";import{checkRateLimits as r}from"./checkRateLimits.js";import{cleanupQueues as o}from"./cleanupQueues.js";import{convertRestError as u}from"./convertRestError.js";import{createInvalidRequestBucket as i}from"./createInvalidRequestBucket.js";import{createRequestBody as c}from"./createRequestBody.js";import{processGlobalQueue as m}from"./processGlobalQueue.js";import{processQueue as a}from"./processQueue.js";import{processRateLimitedPaths as n}from"./processRateLimitedPaths.js";import{processRequest as p}from"./processRequest.js";import{processRequestHeaders as l}from"./processRequestHeaders.js";import{runMethod as d}from"./runMethod.js";import{sendRequest as R}from"./sendRequest.js";import{simplifyUrl as f}from"./simplifyUrl.js";export function createRestManager(h){let g=h.version??e;void 0!==h.customUrl&&(s.BASE_URL=`${h.customUrl}/v${g}`);let j={invalidBucket:i({}),version:g,token:t(h.token),maxRetryCount:h.maxRetryCount??10,secretKey:h.secretKey??"discordeno_best_lib_ever",customUrl:h.customUrl??"",pathQueues:new Map,processingQueue:!1,processingRateLimitedPaths:!1,globallyRateLimited:!1,globalQueue:[],globalQueueProcessing:!1,rateLimitedPaths:new Map,debug:h.debug??function(e){},checkRateLimits:h.checkRateLimits??r,cleanupQueues:h.cleanupQueues??o,processQueue:h.processQueue??a,processRateLimitedPaths:h.processRateLimitedPaths??n,processRequestHeaders:h.processRequestHeaders??l,processRequest:h.processRequest??p,createRequestBody:h.createRequestBody??c,runMethod:h.runMethod??d,simplifyUrl:h.simplifyUrl??f,processGlobalQueue:h.processGlobalQueue??m,convertRestError:h.convertRestError??u,sendRequest:h.sendRequest??R,fetching:h.fetching??function(e){h.debug?.(`[REST - fetching] URL: ${e.url} | ${JSON.stringify(e)}`)},fetched:h.fetched??function(e,s){h.debug?.(`[REST - fetched] URL: ${e.url} | Status: ${s.status} ${JSON.stringify(e)}`)}};return j}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/restManager.ts"],"sourcesContent":["import { API_VERSION, baseEndpoints, removeTokenPrefix } from '@discordeno/utils'\nimport { checkRateLimits } from './checkRateLimits.js'\nimport { cleanupQueues } from './cleanupQueues.js'\nimport { convertRestError } from './convertRestError.js'\nimport { createInvalidRequestBucket } from './createInvalidRequestBucket.js'\nimport { QueueBucket } from './createQueueBucket.js'\nimport { createRequestBody } from './createRequestBody.js'\nimport { processGlobalQueue } from './processGlobalQueue.js'\nimport { processQueue } from './processQueue.js'\nimport { processRateLimitedPaths } from './processRateLimitedPaths.js'\nimport { processRequest } from './processRequest.js'\nimport { processRequestHeaders } from './processRequestHeaders.js'\nimport { RestPayload, RestRateLimitedPath, RestRequest } from './rest.js'\nimport { runMethod } from './runMethod.js'\nimport { RestSendRequestOptions, sendRequest } from './sendRequest.js'\nimport { simplifyUrl } from './simplifyUrl.js'\n\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function createRestManager (options: CreateRestManagerOptions) {\n  const version = options.version ?? API_VERSION\n\n  if (options.customUrl !== undefined) {\n    baseEndpoints.BASE_URL = `${options.customUrl}/v${version}`\n  }\n\n  const rest = {\n    invalidBucket: createInvalidRequestBucket({}),\n    version,\n    token: removeTokenPrefix(options.token),\n    maxRetryCount: options.maxRetryCount ?? 10,\n    secretKey: options.secretKey ?? 'discordeno_best_lib_ever',\n    customUrl: options.customUrl ?? '',\n    pathQueues: new Map<string, QueueBucket>(),\n    processingQueue: false,\n    processingRateLimitedPaths: false,\n    globallyRateLimited: false,\n    globalQueue: [] as Array<{\n      request: RestRequest\n      payload: RestPayload\n      basicURL: string\n      urlToUse: string\n    }>,\n    globalQueueProcessing: false,\n    rateLimitedPaths: new Map<string, RestRateLimitedPath>(),\n\n    debug: options.debug ?? function (_text: string) { },\n    checkRateLimits: options.checkRateLimits ?? checkRateLimits,\n    cleanupQueues: options.cleanupQueues ?? cleanupQueues,\n    processQueue: options.processQueue ?? processQueue,\n    processRateLimitedPaths: options.processRateLimitedPaths ??\n      processRateLimitedPaths,\n    processRequestHeaders: options.processRequestHeaders ??\n      processRequestHeaders,\n    processRequest: options.processRequest ?? processRequest,\n    createRequestBody: options.createRequestBody ?? createRequestBody,\n    runMethod: options.runMethod ?? runMethod,\n    simplifyUrl: options.simplifyUrl ?? simplifyUrl,\n    processGlobalQueue: options.processGlobalQueue ?? processGlobalQueue,\n    convertRestError: options.convertRestError ?? convertRestError,\n    sendRequest: options.sendRequest ?? sendRequest,\n\n    fetching: options.fetching ?? function (opts: RestSendRequestOptions) {\n      options.debug?.(\n        `[REST - fetching] URL: ${opts.url} | ${JSON.stringify(opts)}`\n      )\n    },\n    fetched: options.fetched ?? function (\n      opts: RestSendRequestOptions,\n      response: Response\n    ) {\n      options.debug?.(\n        `[REST - fetched] URL: ${opts.url} | Status: ${response.status} ${JSON.stringify(opts)}`\n      )\n    }\n  }\n\n  return rest\n}\n\nexport interface CreateRestManagerOptions {\n  token: string\n  customUrl?: string\n  maxRetryCount?: number\n  version?: number\n  secretKey?: string\n  debug?: (text: string) => unknown\n  checkRateLimits?: typeof checkRateLimits\n  cleanupQueues?: typeof cleanupQueues\n  processQueue?: typeof processQueue\n  processRateLimitedPaths?: typeof processRateLimitedPaths\n  processRequestHeaders?: typeof processRequestHeaders\n  processRequest?: typeof processRequest\n  createRequestBody?: typeof createRequestBody\n  runMethod?: typeof runMethod\n  simplifyUrl?: typeof simplifyUrl\n  processGlobalQueue?: typeof processGlobalQueue\n  convertRestError?: typeof convertRestError\n  sendRequest?: typeof sendRequest\n  fetching?: (options: RestSendRequestOptions) => void\n  fetched?: (options: RestSendRequestOptions, response: Response) => void\n}\n\nexport type RestManager = ReturnType<typeof createRestManager>\n"],"names":["API_VERSION","baseEndpoints","removeTokenPrefix","checkRateLimits","cleanupQueues","convertRestError","createInvalidRequestBucket","createRequestBody","processGlobalQueue","processQueue","processRateLimitedPaths","processRequest","processRequestHeaders","runMethod","sendRequest","simplifyUrl","createRestManager","options","version","undefined","customUrl","BASE_URL","rest","invalidBucket","token","maxRetryCount","secretKey","pathQueues","Map","processingQueue","processingRateLimitedPaths","globallyRateLimited","globalQueue","globalQueueProcessing","rateLimitedPaths","debug","_text","fetching","opts","url","JSON","stringify","fetched","response","status"],"mappings":"AAAA,OAASA,eAAAA,CAAW,CAAEC,iBAAAA,CAAa,CAAEC,qBAAAA,CAAiB,KAAQ,mBAAmB,AACjF,QAASC,mBAAAA,CAAe,KAAQ,sBAAsB,AACtD,QAASC,iBAAAA,CAAa,KAAQ,oBAAoB,AAClD,QAASC,oBAAAA,CAAgB,KAAQ,uBAAuB,AACxD,QAASC,8BAAAA,CAA0B,KAAQ,iCAAiC,AAE5E,QAASC,qBAAAA,CAAiB,KAAQ,wBAAwB,AAC1D,QAASC,sBAAAA,CAAkB,KAAQ,yBAAyB,AAC5D,QAASC,gBAAAA,CAAY,KAAQ,mBAAmB,AAChD,QAASC,2BAAAA,CAAuB,KAAQ,8BAA8B,AACtE,QAASC,kBAAAA,CAAc,KAAQ,qBAAqB,AACpD,QAASC,yBAAAA,CAAqB,KAAQ,4BAA4B,AAElE,QAASC,aAAAA,CAAS,KAAQ,gBAAgB,AAC1C,QAAiCC,eAAAA,CAAW,KAAQ,kBAAkB,AACtE,QAASC,eAAAA,CAAW,KAAQ,kBAAkB,AAG9C,QAAO,SAASC,kBAAmBC,CAAiC,CAAE,CACpE,IAAMC,EAAUD,EAAQC,OAAO,EAAIlB,CAETmB,MAAAA,IAAtBF,EAAQG,SAAS,EACnBnB,CAAAA,EAAcoB,QAAQ,CAAG,CAAC,EAAEJ,EAAQG,SAAS,CAAC,EAAE,EAAEF,EAAQ,CAAC,AAAD,EAG5D,IAAMI,EAAO,CACXC,cAAejB,EAA2B,CAAC,GAC3CY,QAAAA,EACAM,MAAOtB,EAAkBe,EAAQO,KAAK,EACtCC,cAAeR,EAAQQ,aAAa,EAAI,GACxCC,UAAWT,EAAQS,SAAS,EAAI,2BAChCN,UAAWH,EAAQG,SAAS,EAAI,GAChCO,WAAY,IAAIC,IAChBC,gBAAiB,CAAA,EACjBC,2BAA4B,CAAA,EAC5BC,oBAAqB,CAAA,EACrBC,YAAa,EAAE,CAMfC,sBAAuB,CAAA,EACvBC,iBAAkB,IAAIN,IAEtBO,MAAOlB,EAAQkB,KAAK,EAAI,SAAUC,CAAa,CAAE,CAAE,EACnDjC,gBAAiBc,EAAQd,eAAe,EAAIA,EAC5CC,cAAea,EAAQb,aAAa,EAAIA,EACxCK,aAAcQ,EAAQR,YAAY,EAAIA,EACtCC,wBAAyBO,EAAQP,uBAAuB,EACtDA,EACFE,sBAAuBK,EAAQL,qBAAqB,EAClDA,EACFD,eAAgBM,EAAQN,cAAc,EAAIA,EAC1CJ,kBAAmBU,EAAQV,iBAAiB,EAAIA,EAChDM,UAAWI,EAAQJ,SAAS,EAAIA,EAChCE,YAAaE,EAAQF,WAAW,EAAIA,EACpCP,mBAAoBS,EAAQT,kBAAkB,EAAIA,EAClDH,iBAAkBY,EAAQZ,gBAAgB,EAAIA,EAC9CS,YAAaG,EAAQH,WAAW,EAAIA,EAEpCuB,SAAUpB,EAAQoB,QAAQ,EAAI,SAAUC,CAA4B,CAAE,CACpErB,EAAQkB,KAAK,GACX,CAAC,uBAAuB,EAAEG,EAAKC,GAAG,CAAC,GAAG,EAAEC,KAAKC,SAAS,CAACH,GAAM,CAAC,CAElE,EACAI,QAASzB,EAAQyB,OAAO,EAAI,SAC1BJ,CAA4B,CAC5BK,CAAkB,CAClB,CACA1B,EAAQkB,KAAK,GACX,CAAC,sBAAsB,EAAEG,EAAKC,GAAG,CAAC,WAAW,EAAEI,EAASC,MAAM,CAAC,CAAC,EAAEJ,KAAKC,SAAS,CAACH,GAAM,CAAC,CAE5F,CACF,EAEA,OAAOhB,CACT,CAAC"}
+import{Errors as e}from"@discordeno/types";import{API_VERSION as t,baseEndpoints as o,bigintToSnowflake as r,getBotIdFromToken as i,removeTokenPrefix as s,snowflakeToBigint as a}from"@discordeno/utils";import{checkRateLimits as n}from"./checkRateLimits.js";import{cleanupQueues as c}from"./cleanupQueues.js";import{convertRestError as m}from"./convertRestError.js";import{createInvalidRequestBucket as p}from"./createInvalidRequestBucket.js";import{createRequestBody as u}from"./createRequestBody.js";import*as l from"./helpers/index.js";import{processGlobalQueue as d}from"./processGlobalQueue.js";import{processQueue as f}from"./processQueue.js";import{processRateLimitedPaths as h}from"./processRateLimitedPaths.js";import{processRequest as R}from"./processRequest.js";import{processRequestHeaders as v}from"./processRequestHeaders.js";import{routes as g}from"./routes.js";import{runMethod as b}from"./runMethod.js";import{sendRequest as y}from"./sendRequest.js";import{simplifyUrl as C}from"./simplifyUrl.js";import{transformActivity as k,transformActivityToDiscordActivity as j,transformAllowedMentionsToDiscordAllowedMentions as w,transformApplication as L,transformApplicationCommand as q,transformApplicationCommandOption as O,transformApplicationCommandOptionChoice as Q,transformApplicationCommandOptionChoiceToDiscordApplicationCommandOptionChoice as E,transformApplicationCommandOptionToDiscordApplicationCommandOption as S,transformApplicationCommandPermission as x,transformApplicationCommandToDiscordApplicationCommand as B,transformApplicationToDiscordApplication as M,transformAttachment as P,transformAttachmentToDiscordAttachment as U,transformAuditLogEntry as H,transformAutoModerationActionExecution as I,transformAutoModerationRule as $,transformChannel as A,transformComponent as T,transformComponentToDiscordComponent as _,transformCreateApplicationCommandToDiscordCreateApplicationCommand as G,transformEmbed as D,transformEmbedToDiscordEmbed as J,transformEmoji as K,transformGatewayBot as N,transformGuild as z,transformIntegration as F,transformInteraction as V,transformInteractionDataOption as W,transformInteractionResponseToDiscordInteractionResponse as X,transformInvite as Y,transformMember as Z,transformMemberToDiscordMember as ee,transformMessage as et,transformPresence as eo,transformRole as er,transformScheduledEvent as ei,transformStageInstance as es,transformSticker as ea,transformStickerPack as en,transformTeam as ec,transformTeamToDiscordTeam as em,transformTemplate as ep,transformThreadMember as eu,transformUser as el,transformUserToDiscordUser as ed,transformVoiceRegion as ef,transformVoiceState as eh,transformWebhook as eR,transformWelcomeScreen as ev,transformWidget as eg,transformWidgetSettings as eb}from"./transformers/index.js";export function createRestManager(r){let a=r.version??t;void 0!==r.customUrl&&(o.BASE_URL=`${r.customUrl}/v${a}`);let l={invalidBucket:p({}),version:a,token:s(r.token),maxRetryCount:r.maxRetryCount??10,secretKey:r.secretKey??"discordeno_best_lib_ever",customUrl:r.customUrl??"",pathQueues:new Map,processingQueue:!1,processingRateLimitedPaths:!1,globallyRateLimited:!1,globalQueue:[],globalQueueProcessing:!1,rateLimitedPaths:new Map,debug:r.debug??function(e){},checkRateLimits:r.checkRateLimits??n,cleanupQueues:r.cleanupQueues??c,processQueue:r.processQueue??f,processRateLimitedPaths:r.processRateLimitedPaths??h,processRequestHeaders:r.processRequestHeaders??v,processRequest:r.processRequest??R,createRequestBody:r.createRequestBody??u,runMethod:r.runMethod??b,simplifyUrl:r.simplifyUrl??C,processGlobalQueue:r.processGlobalQueue??d,convertRestError:r.convertRestError??m,sendRequest:r.sendRequest??y,fetching:r.fetching??function(e){r.debug?.(`[REST - fetching] URL: ${e.url} | ${JSON.stringify(e)}`)},fetched:r.fetched??function(e,t){r.debug?.(`[REST - fetched] URL: ${e.url} | Status: ${t.status} ${JSON.stringify(e)}`)},transformers:createTransformers(r.transformers??{}),constants:{routes:g,Errors:e},id:r.botId??i(r.token),applicationId:r.applicationId??r.botId??i(r.token),helpers:{}};return l.helpers=createHelpers(l,r.helpers??{}),l}export function createTransformers(e){return{reverse:{allowedMentions:e.reverse?.allowedMentions??w,embed:e.reverse?.embed??J,component:e.reverse?.component??_,activity:e.reverse?.activity??j,member:e.reverse?.member??ee,user:e.reverse?.user??ed,team:e.reverse?.team??em,application:e.reverse?.application??M,snowflake:e.reverse?.snowflake??r,createApplicationCommand:e.reverse?.createApplicationCommand??G,applicationCommand:e.reverse?.applicationCommand??B,applicationCommandOption:e.reverse?.applicationCommandOption??S,applicationCommandOptionChoice:e.reverse?.applicationCommandOptionChoice??E,interactionResponse:e.reverse?.interactionResponse??X,attachment:e.reverse?.attachment??U},automodRule:e.automodRule??$,automodActionExecution:e.automodActionExecution??I,activity:e.activity??k,application:e.application??L,attachment:e.attachment??P,channel:e.channel??A,component:e.component??T,embed:e.embed??D,emoji:e.emoji??K,guild:e.guild??z,integration:e.integration??F,interaction:e.interaction??V,interactionDataOptions:e.interactionDataOptions??W,invite:e.invite??Y,member:e.member??Z,message:e.message??et,presence:e.presence??eo,role:e.role??er,user:e.user??el,team:e.team??ec,voiceState:e.voiceState??eh,snowflake:e.snowflake??a,webhook:e.webhook??eR,auditLogEntry:e.auditLogEntry??H,applicationCommand:e.applicationCommand??q,applicationCommandOption:e.applicationCommandOption??O,applicationCommandPermission:e.applicationCommandPermission??x,scheduledEvent:e.scheduledEvent??ei,threadMember:e.threadMember??eu,welcomeScreen:e.welcomeScreen??ev,voiceRegion:e.voiceRegion??ef,widget:e.widget??eg,widgetSettings:e.widgetSettings??eb,stageInstance:e.stageInstance??es,sticker:e.sticker??ea,stickerPack:e.stickerPack??en,gatewayBot:e.gatewayBot??N,applicationCommandOptionChoice:e.applicationCommandOptionChoice??Q,template:e.template??ep}}export const defaultHelpers={...l};export function createHelpers(e,t){let o={};for(let[r,i]of Object.entries({...createBaseHelpers(t??{})}))o[r]=(...t)=>i(e,...t);return o}export function createBaseHelpers(e){return{...defaultHelpers,...e}}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/restManager.ts"],"sourcesContent":["import {\n  AllowedMentions,\n  BigString,\n  DiscordActivity,\n  DiscordAllowedMentions,\n  DiscordApplication,\n  DiscordApplicationCommand,\n  DiscordApplicationCommandOption,\n  DiscordApplicationCommandOptionChoice,\n  DiscordAttachment,\n  DiscordAuditLogEntry,\n  DiscordAutoModerationActionExecution,\n  DiscordAutoModerationRule,\n  DiscordChannel,\n  DiscordComponent,\n  DiscordCreateApplicationCommand,\n  DiscordEmbed,\n  DiscordEmoji,\n  DiscordGetGatewayBot,\n  DiscordGuild,\n  DiscordGuildApplicationCommandPermissions,\n  DiscordGuildWidget,\n  DiscordGuildWidgetSettings,\n  DiscordIntegrationCreateUpdate,\n  DiscordInteraction,\n  DiscordInteractionDataOption,\n  DiscordInteractionResponse,\n  DiscordInviteCreate,\n  DiscordMember,\n  DiscordMessage,\n  DiscordPresenceUpdate,\n  DiscordRole,\n  DiscordScheduledEvent,\n  DiscordStageInstance,\n  DiscordSticker,\n  DiscordStickerPack,\n  DiscordTeam,\n  DiscordTemplate,\n  DiscordThreadMember,\n  DiscordUser,\n  DiscordVoiceRegion,\n  DiscordVoiceState,\n  DiscordWebhook,\n  DiscordWelcomeScreen,\n  Errors,\n  GetGatewayBot\n} from '@discordeno/types'\nimport {\n  API_VERSION,\n  baseEndpoints,\n  bigintToSnowflake,\n  getBotIdFromToken,\n  removeTokenPrefix,\n  snowflakeToBigint\n} from '@discordeno/utils'\nimport { checkRateLimits } from './checkRateLimits.js'\nimport { cleanupQueues } from './cleanupQueues.js'\nimport { convertRestError } from './convertRestError.js'\nimport {\n  createInvalidRequestBucket,\n  InvalidRequestBucket\n} from './createInvalidRequestBucket.js'\nimport { QueueBucket } from './createQueueBucket.js'\nimport { createRequestBody } from './createRequestBody.js'\nimport * as helpers from './helpers/index.js'\nimport { processGlobalQueue } from './processGlobalQueue.js'\nimport { processQueue } from './processQueue.js'\nimport { processRateLimitedPaths } from './processRateLimitedPaths.js'\nimport { processRequest } from './processRequest.js'\nimport { processRequestHeaders } from './processRequestHeaders.js'\nimport { RestPayload, RestRateLimitedPath, RestRequest } from './rest.js'\nimport { routes } from './routes.js'\nimport { runMethod } from './runMethod.js'\nimport { RestSendRequestOptions, sendRequest } from './sendRequest.js'\nimport { simplifyUrl } from './simplifyUrl.js'\nimport {\n  Activity,\n  Application,\n  ApplicationCommand,\n  ApplicationCommandOption,\n  ApplicationCommandOptionChoice,\n  ApplicationCommandPermission,\n  Attachment,\n  AuditLogEntry,\n  AutoModerationActionExecution,\n  AutoModerationRule,\n  Channel,\n  Component,\n  Embed,\n  Emoji,\n  Guild,\n  GuildWidget,\n  GuildWidgetSettings,\n  Integration,\n  Interaction,\n  InteractionDataOption,\n  Invite,\n  Member,\n  Message,\n  PresenceUpdate,\n  Role,\n  ScheduledEvent,\n  StageInstance,\n  Sticker,\n  StickerPack,\n  Team,\n  Template,\n  ThreadMember,\n  transformActivity,\n  transformActivityToDiscordActivity,\n  transformAllowedMentionsToDiscordAllowedMentions,\n  transformApplication,\n  transformApplicationCommand,\n  transformApplicationCommandOption,\n  transformApplicationCommandOptionChoice,\n  transformApplicationCommandOptionChoiceToDiscordApplicationCommandOptionChoice,\n  transformApplicationCommandOptionToDiscordApplicationCommandOption,\n  transformApplicationCommandPermission,\n  transformApplicationCommandToDiscordApplicationCommand,\n  transformApplicationToDiscordApplication,\n  transformAttachment,\n  transformAttachmentToDiscordAttachment,\n  transformAuditLogEntry,\n  transformAutoModerationActionExecution,\n  transformAutoModerationRule,\n  transformChannel,\n  transformComponent,\n  transformComponentToDiscordComponent,\n  transformCreateApplicationCommandToDiscordCreateApplicationCommand,\n  transformEmbed,\n  transformEmbedToDiscordEmbed,\n  transformEmoji,\n  transformGatewayBot,\n  transformGuild,\n  transformIntegration,\n  transformInteraction,\n  transformInteractionDataOption,\n  transformInteractionResponseToDiscordInteractionResponse,\n  transformInvite,\n  transformMember,\n  transformMemberToDiscordMember,\n  transformMessage,\n  transformPresence,\n  transformRole,\n  transformScheduledEvent,\n  transformStageInstance,\n  transformSticker,\n  transformStickerPack,\n  transformTeam,\n  transformTeamToDiscordTeam,\n  transformTemplate,\n  transformThreadMember,\n  transformUser,\n  transformUserToDiscordUser,\n  transformVoiceRegion,\n  transformVoiceState,\n  transformWebhook,\n  transformWelcomeScreen,\n  transformWidget,\n  transformWidgetSettings,\n  User,\n  VoiceRegions,\n  VoiceState,\n  Webhook,\n  WelcomeScreen\n} from './transformers/index.js'\nimport { CreateApplicationCommand, InteractionResponse } from './types.js'\n\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function createRestManager (\n  options: CreateRestManagerOptions\n): RestManager {\n  const version = options.version ?? API_VERSION\n\n  if (options.customUrl !== undefined) {\n    baseEndpoints.BASE_URL = `${options.customUrl}/v${version}`\n  }\n\n  const rest = {\n    invalidBucket: createInvalidRequestBucket({}),\n    version,\n    token: removeTokenPrefix(options.token),\n    maxRetryCount: options.maxRetryCount ?? 10,\n    secretKey: options.secretKey ?? 'discordeno_best_lib_ever',\n    customUrl: options.customUrl ?? '',\n    pathQueues: new Map<string, QueueBucket>(),\n    processingQueue: false,\n    processingRateLimitedPaths: false,\n    globallyRateLimited: false,\n    globalQueue: [] as Array<{\n      request: RestRequest\n      payload: RestPayload\n      basicURL: string\n      urlToUse: string\n    }>,\n    globalQueueProcessing: false,\n    rateLimitedPaths: new Map<string, RestRateLimitedPath>(),\n\n    debug: options.debug ?? function (_text: string) {},\n    checkRateLimits: options.checkRateLimits ?? checkRateLimits,\n    cleanupQueues: options.cleanupQueues ?? cleanupQueues,\n    processQueue: options.processQueue ?? processQueue,\n    processRateLimitedPaths:\n      options.processRateLimitedPaths ?? processRateLimitedPaths,\n    processRequestHeaders:\n      options.processRequestHeaders ?? processRequestHeaders,\n    processRequest: options.processRequest ?? processRequest,\n    createRequestBody: options.createRequestBody ?? createRequestBody,\n    runMethod: options.runMethod ?? runMethod,\n    simplifyUrl: options.simplifyUrl ?? simplifyUrl,\n    processGlobalQueue: options.processGlobalQueue ?? processGlobalQueue,\n    convertRestError: options.convertRestError ?? convertRestError,\n    sendRequest: options.sendRequest ?? sendRequest,\n    fetching:\n      options.fetching ??\n      function (opts: RestSendRequestOptions) {\n        options.debug?.(\n          `[REST - fetching] URL: ${opts.url} | ${JSON.stringify(opts)}`\n        )\n      },\n    fetched:\n      options.fetched ??\n      function (opts: RestSendRequestOptions, response: Response) {\n        options.debug?.(\n          `[REST - fetched] URL: ${opts.url} | Status: ${\n            response.status\n          } ${JSON.stringify(opts)}`\n        )\n      },\n    transformers: createTransformers(options.transformers ?? {}),\n    constants: {\n      routes,\n      Errors\n    },\n    id: options.botId ?? getBotIdFromToken(options.token),\n    applicationId:\n      options.applicationId ??\n      options.botId ??\n      getBotIdFromToken(options.token),\n    helpers: {} as FinalHelpers\n  } as RestManager\n\n  rest.helpers = createHelpers(rest, options.helpers ?? {})\n\n  return rest\n}\n\nexport interface CreateRestManagerOptions {\n  token: string\n  customUrl?: string\n  maxRetryCount?: number\n  version?: number\n  secretKey?: string\n  debug?: (text: string) => unknown\n  checkRateLimits?: typeof checkRateLimits\n  cleanupQueues?: typeof cleanupQueues\n  processQueue?: typeof processQueue\n  processRateLimitedPaths?: typeof processRateLimitedPaths\n  processRequestHeaders?: typeof processRequestHeaders\n  processRequest?: typeof processRequest\n  createRequestBody?: typeof createRequestBody\n  runMethod?: typeof runMethod\n  simplifyUrl?: typeof simplifyUrl\n  processGlobalQueue?: typeof processGlobalQueue\n  convertRestError?: typeof convertRestError\n  sendRequest?: typeof sendRequest\n  fetching?: (options: RestSendRequestOptions) => void\n  fetched?: (options: RestSendRequestOptions, response: Response) => void\n  transformers?: Partial<ReturnType<typeof createTransformers>>\n  helpers?: Partial<Helpers>\n  applicationId?: bigint\n  botId?: bigint\n}\n\nexport interface RestManager {\n  invalidBucket: InvalidRequestBucket\n  version: number\n  token: string\n  maxRetryCount: number\n  secretKey: string\n  customUrl: string\n  pathQueues: Map<string, QueueBucket>\n  processingQueue: boolean\n  processingRateLimitedPaths: boolean\n  globallyRateLimited: boolean\n  globalQueue: Array<{\n    request: RestRequest\n    payload: RestPayload\n    basicURL: string\n    urlToUse: string\n  }>\n  globalQueueProcessing: boolean\n  rateLimitedPaths: Map<string, RestRateLimitedPath>\n  debug: (text: string) => unknown\n  checkRateLimits: typeof checkRateLimits\n  cleanupQueues: typeof cleanupQueues\n  processQueue: typeof processQueue\n  processRateLimitedPaths: typeof processRateLimitedPaths\n  processRequestHeaders: typeof processRequestHeaders\n  processRequest: typeof processRequest\n  createRequestBody: typeof createRequestBody\n  runMethod: typeof runMethod\n  simplifyUrl: typeof simplifyUrl\n  processGlobalQueue: typeof processGlobalQueue\n  convertRestError: typeof convertRestError\n  sendRequest: typeof sendRequest\n  fetching: (options: RestSendRequestOptions) => void\n  fetched: (options: RestSendRequestOptions, response: Response) => void\n  transformers: Transformers\n  constants: {\n    routes: typeof routes\n    Errors: typeof Errors\n  }\n  id: bigint\n  applicationId: bigint\n  helpers: FinalHelpers\n}\n\nexport interface Transformers {\n  reverse: {\n    allowedMentions: (\n      rest: RestManager,\n      payload: AllowedMentions\n    ) => DiscordAllowedMentions\n    embed: (rest: RestManager, payload: Embed) => DiscordEmbed\n    component: (rest: RestManager, payload: Component) => DiscordComponent\n    activity: (rest: RestManager, payload: Activity) => DiscordActivity\n    member: (rest: RestManager, payload: Member) => DiscordMember\n    user: (rest: RestManager, payload: User) => DiscordUser\n    team: (rest: RestManager, payload: Team) => DiscordTeam\n    application: (\n      rest: RestManager,\n      payload: Application\n    ) => DiscordApplication\n    snowflake: (snowflake: BigString) => string\n    createApplicationCommand: (\n      rest: RestManager,\n      payload: CreateApplicationCommand\n    ) => DiscordCreateApplicationCommand\n    applicationCommand: (\n      rest: RestManager,\n      payload: ApplicationCommand\n    ) => DiscordApplicationCommand\n    applicationCommandOption: (\n      rest: RestManager,\n      payload: ApplicationCommandOption\n    ) => DiscordApplicationCommandOption\n    applicationCommandOptionChoice: (\n      rest: RestManager,\n      payload: ApplicationCommandOptionChoice\n    ) => DiscordApplicationCommandOptionChoice\n    interactionResponse: (\n      rest: RestManager,\n      payload: InteractionResponse\n    ) => DiscordInteractionResponse\n    attachment: (rest: RestManager, payload: Attachment) => DiscordAttachment\n  }\n  snowflake: (snowflake: BigString) => bigint\n  gatewayBot: (payload: DiscordGetGatewayBot) => GetGatewayBot\n  automodRule: (\n    rest: RestManager,\n    payload: DiscordAutoModerationRule\n  ) => AutoModerationRule\n  automodActionExecution: (\n    rest: RestManager,\n    payload: DiscordAutoModerationActionExecution\n  ) => AutoModerationActionExecution\n  channel: (\n    rest: RestManager,\n    payload: { channel: DiscordChannel } & { guildId?: bigint }\n  ) => Channel\n  guild: (\n    rest: RestManager,\n    payload: { guild: DiscordGuild } & { shardId: number }\n  ) => Guild\n  user: (rest: RestManager, payload: DiscordUser) => User\n  member: (\n    rest: RestManager,\n    payload: DiscordMember,\n    guildId: bigint,\n    userId: bigint\n  ) => Member\n  message: (rest: RestManager, payload: DiscordMessage) => Message\n  role: (\n    rest: RestManager,\n    payload: { role: DiscordRole } & { guildId: bigint }\n  ) => Role\n  voiceState: (\n    rest: RestManager,\n    payload: { voiceState: DiscordVoiceState } & { guildId: bigint }\n  ) => VoiceState\n  interaction: (rest: RestManager, payload: DiscordInteraction) => Interaction\n  interactionDataOptions: (\n    rest: RestManager,\n    payload: DiscordInteractionDataOption\n  ) => InteractionDataOption\n  integration: (\n    rest: RestManager,\n    payload: DiscordIntegrationCreateUpdate\n  ) => Integration\n  invite: (rest: RestManager, invite: DiscordInviteCreate) => Invite\n  application: (rest: RestManager, payload: DiscordApplication) => Application\n  team: (rest: RestManager, payload: DiscordTeam) => Team\n  emoji: (rest: RestManager, payload: DiscordEmoji) => Emoji\n  activity: (rest: RestManager, payload: DiscordActivity) => Activity\n  presence: (\n    rest: RestManager,\n    payload: DiscordPresenceUpdate\n  ) => PresenceUpdate\n  attachment: (rest: RestManager, payload: DiscordAttachment) => Attachment\n  embed: (rest: RestManager, payload: DiscordEmbed) => Embed\n  component: (rest: RestManager, payload: DiscordComponent) => Component\n  webhook: (rest: RestManager, payload: DiscordWebhook) => Webhook\n  auditLogEntry: (\n    rest: RestManager,\n    payload: DiscordAuditLogEntry\n  ) => AuditLogEntry\n  applicationCommand: (\n    rest: RestManager,\n    payload: DiscordApplicationCommand\n  ) => ApplicationCommand\n  applicationCommandOption: (\n    rest: RestManager,\n    payload: DiscordApplicationCommandOption\n  ) => ApplicationCommandOption\n  applicationCommandPermission: (\n    rest: RestManager,\n    payload: DiscordGuildApplicationCommandPermissions\n  ) => ApplicationCommandPermission\n  scheduledEvent: (\n    rest: RestManager,\n    payload: DiscordScheduledEvent\n  ) => ScheduledEvent\n  threadMember: (\n    rest: RestManager,\n    payload: DiscordThreadMember\n  ) => ThreadMember\n  welcomeScreen: (\n    rest: RestManager,\n    payload: DiscordWelcomeScreen\n  ) => WelcomeScreen\n  voiceRegion: (rest: RestManager, payload: DiscordVoiceRegion) => VoiceRegions\n  widget: (rest: RestManager, payload: DiscordGuildWidget) => GuildWidget\n  widgetSettings: (\n    rest: RestManager,\n    payload: DiscordGuildWidgetSettings\n  ) => GuildWidgetSettings\n  stageInstance: (\n    rest: RestManager,\n    payload: DiscordStageInstance\n  ) => StageInstance\n  sticker: (rest: RestManager, payload: DiscordSticker) => Sticker\n  stickerPack: (rest: RestManager, payload: DiscordStickerPack) => StickerPack\n  applicationCommandOptionChoice: (\n    rest: RestManager,\n    payload: DiscordApplicationCommandOptionChoice\n  ) => ApplicationCommandOptionChoice\n  template: (rest: RestManager, payload: DiscordTemplate) => Template\n}\n\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function createTransformers (\n  options: Partial<Transformers>\n): Transformers {\n  return {\n    reverse: {\n      allowedMentions:\n        options.reverse?.allowedMentions ??\n        transformAllowedMentionsToDiscordAllowedMentions,\n      embed: options.reverse?.embed ?? transformEmbedToDiscordEmbed,\n      component:\n        options.reverse?.component ?? transformComponentToDiscordComponent,\n      activity: options.reverse?.activity ?? transformActivityToDiscordActivity,\n      member: options.reverse?.member ?? transformMemberToDiscordMember,\n      user: options.reverse?.user ?? transformUserToDiscordUser,\n      team: options.reverse?.team ?? transformTeamToDiscordTeam,\n      application:\n        options.reverse?.application ??\n        transformApplicationToDiscordApplication,\n      snowflake: options.reverse?.snowflake ?? bigintToSnowflake,\n      createApplicationCommand:\n        options.reverse?.createApplicationCommand ??\n        transformCreateApplicationCommandToDiscordCreateApplicationCommand,\n      applicationCommand:\n        options.reverse?.applicationCommand ??\n        transformApplicationCommandToDiscordApplicationCommand,\n      applicationCommandOption:\n        options.reverse?.applicationCommandOption ??\n        transformApplicationCommandOptionToDiscordApplicationCommandOption,\n      applicationCommandOptionChoice:\n        options.reverse?.applicationCommandOptionChoice ??\n        transformApplicationCommandOptionChoiceToDiscordApplicationCommandOptionChoice,\n      interactionResponse:\n        options.reverse?.interactionResponse ??\n        transformInteractionResponseToDiscordInteractionResponse,\n      attachment:\n        options.reverse?.attachment ?? transformAttachmentToDiscordAttachment\n    },\n    automodRule: options.automodRule ?? transformAutoModerationRule,\n    automodActionExecution:\n      options.automodActionExecution ?? transformAutoModerationActionExecution,\n    activity: options.activity ?? transformActivity,\n    application: options.application ?? transformApplication,\n    attachment: options.attachment ?? transformAttachment,\n    channel: options.channel ?? transformChannel,\n    component: options.component ?? transformComponent,\n    embed: options.embed ?? transformEmbed,\n    emoji: options.emoji ?? transformEmoji,\n    guild: options.guild ?? transformGuild,\n    integration: options.integration ?? transformIntegration,\n    interaction: options.interaction ?? transformInteraction,\n    interactionDataOptions:\n      options.interactionDataOptions ?? transformInteractionDataOption,\n    invite: options.invite ?? transformInvite,\n    member: options.member ?? transformMember,\n    message: options.message ?? transformMessage,\n    presence: options.presence ?? transformPresence,\n    role: options.role ?? transformRole,\n    user: options.user ?? transformUser,\n    team: options.team ?? transformTeam,\n    voiceState: options.voiceState ?? transformVoiceState,\n    snowflake: options.snowflake ?? snowflakeToBigint,\n    webhook: options.webhook ?? transformWebhook,\n    auditLogEntry: options.auditLogEntry ?? transformAuditLogEntry,\n    applicationCommand:\n      options.applicationCommand ?? transformApplicationCommand,\n    applicationCommandOption:\n      options.applicationCommandOption ?? transformApplicationCommandOption,\n    applicationCommandPermission:\n      options.applicationCommandPermission ??\n      transformApplicationCommandPermission,\n    scheduledEvent: options.scheduledEvent ?? transformScheduledEvent,\n    threadMember: options.threadMember ?? transformThreadMember,\n    welcomeScreen: options.welcomeScreen ?? transformWelcomeScreen,\n    voiceRegion: options.voiceRegion ?? transformVoiceRegion,\n    widget: options.widget ?? transformWidget,\n    widgetSettings: options.widgetSettings ?? transformWidgetSettings,\n    stageInstance: options.stageInstance ?? transformStageInstance,\n    sticker: options.sticker ?? transformSticker,\n    stickerPack: options.stickerPack ?? transformStickerPack,\n    gatewayBot: options.gatewayBot ?? transformGatewayBot,\n    applicationCommandOptionChoice:\n      options.applicationCommandOptionChoice ??\n      transformApplicationCommandOptionChoice,\n    template: options.template ?? transformTemplate\n  }\n}\n\nexport const defaultHelpers = { ...helpers }\nexport type DefaultHelpers = typeof defaultHelpers\n// deno-lint-ignore no-empty-interface\nexport interface Helpers extends DefaultHelpers {} // Use interface for declaration merging\n\nexport function createHelpers (\n  rest: RestManager,\n  customHelpers?: Partial<Helpers>\n): FinalHelpers {\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const converted = {} as FinalHelpers\n  for (const [name, fun] of Object.entries({\n    ...createBaseHelpers(customHelpers ?? {})\n  })) {\n    // @ts-expect-error - TODO: make the types better\n    converted[name as keyof FinalHelpers] = (\n      ...args: RemoveFirstFromTuple<Parameters<typeof fun>>\n    ) =>\n      // @ts-expect-error - TODO: make the types better\n      fun(rest, ...args)\n  }\n\n  return converted\n}\n\nexport function createBaseHelpers (\n  options: Partial<Helpers>\n): DefaultHelpers & Partial<Helpers> {\n  return {\n    ...defaultHelpers,\n    ...options\n  }\n}\n\nexport type RemoveFirstFromTuple<T extends any[]> = T['length'] extends 0\n  ? []\n  : ((...b: T) => void) extends (a: any, ...b: infer I) => void\n      ? I\n      : []\nexport type FinalHelpers = {\n  [K in keyof Helpers]: (\n    ...args: RemoveFirstFromTuple<Parameters<Helpers[K]>>\n  ) => ReturnType<Helpers[K]>;\n}\n"],"names":["Errors","API_VERSION","baseEndpoints","bigintToSnowflake","getBotIdFromToken","removeTokenPrefix","snowflakeToBigint","checkRateLimits","cleanupQueues","convertRestError","createInvalidRequestBucket","createRequestBody","helpers","processGlobalQueue","processQueue","processRateLimitedPaths","processRequest","processRequestHeaders","routes","runMethod","sendRequest","simplifyUrl","transformActivity","transformActivityToDiscordActivity","transformAllowedMentionsToDiscordAllowedMentions","transformApplication","transformApplicationCommand","transformApplicationCommandOption","transformApplicationCommandOptionChoice","transformApplicationCommandOptionChoiceToDiscordApplicationCommandOptionChoice","transformApplicationCommandOptionToDiscordApplicationCommandOption","transformApplicationCommandPermission","transformApplicationCommandToDiscordApplicationCommand","transformApplicationToDiscordApplication","transformAttachment","transformAttachmentToDiscordAttachment","transformAuditLogEntry","transformAutoModerationActionExecution","transformAutoModerationRule","transformChannel","transformComponent","transformComponentToDiscordComponent","transformCreateApplicationCommandToDiscordCreateApplicationCommand","transformEmbed","transformEmbedToDiscordEmbed","transformEmoji","transformGatewayBot","transformGuild","transformIntegration","transformInteraction","transformInteractionDataOption","transformInteractionResponseToDiscordInteractionResponse","transformInvite","transformMember","transformMemberToDiscordMember","transformMessage","transformPresence","transformRole","transformScheduledEvent","transformStageInstance","transformSticker","transformStickerPack","transformTeam","transformTeamToDiscordTeam","transformTemplate","transformThreadMember","transformUser","transformUserToDiscordUser","transformVoiceRegion","transformVoiceState","transformWebhook","transformWelcomeScreen","transformWidget","transformWidgetSettings","createRestManager","options","version","undefined","customUrl","BASE_URL","rest","invalidBucket","token","maxRetryCount","secretKey","pathQueues","Map","processingQueue","processingRateLimitedPaths","globallyRateLimited","globalQueue","globalQueueProcessing","rateLimitedPaths","debug","_text","fetching","opts","url","JSON","stringify","fetched","response","status","transformers","createTransformers","constants","id","botId","applicationId","createHelpers","reverse","allowedMentions","embed","component","activity","member","user","team","application","snowflake","createApplicationCommand","applicationCommand","applicationCommandOption","applicationCommandOptionChoice","interactionResponse","attachment","automodRule","automodActionExecution","channel","emoji","guild","integration","interaction","interactionDataOptions","invite","message","presence","role","voiceState","webhook","auditLogEntry","applicationCommandPermission","scheduledEvent","threadMember","welcomeScreen","voiceRegion","widget","widgetSettings","stageInstance","sticker","stickerPack","gatewayBot","template","defaultHelpers","customHelpers","converted","name","fun","Object","entries","createBaseHelpers","args"],"mappings":"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"}

package/dist/routes.d.ts

@@ -0,0 +1,119 @@
+import { BigString } from '@discordeno/types';
+import { GetBans, GetGuildAuditLog, GetGuildPruneCountQuery, GetInvite, GetMessagesOptions, GetReactions, GetScheduledEventUsers, ListArchivedThreads, ListGuildMembers } from './helpers/index.js';
+export declare const routes: {
+    GATEWAY_BOT: () => string;
+    AUTOMOD_RULES: (guildId: BigString) => string;
+    AUTOMOD_RULE: (guildId: BigString, ruleId: BigString) => string;
+    CHANNEL: (channelId: BigString) => string;
+    CHANNEL_MESSAGE: (channelId: BigString, messageId: BigString) => string;
+    CHANNEL_MESSAGES: (channelId: BigString, options?: GetMessagesOptions) => string;
+    CHANNEL_PIN: (channelId: BigString, messageId: BigString) => string;
+    CHANNEL_PINS: (channelId: BigString) => string;
+    CHANNEL_BULK_DELETE: (channelId: BigString) => string;
+    CHANNEL_INVITES: (channelId: BigString) => string;
+    CHANNEL_WEBHOOKS: (channelId: BigString) => string;
+    CHANNEL_MESSAGE_REACTION_ME: (channelId: BigString, messageId: BigString, emoji: string) => string;
+    CHANNEL_MESSAGE_REACTION_USER: (channelId: BigString, messageId: BigString, emoji: string, userId: BigString) => string;
+    CHANNEL_MESSAGE_REACTIONS: (channelId: BigString, messageId: BigString) => string;
+    CHANNEL_MESSAGE_REACTION: (channelId: BigString, messageId: BigString, emoji: string, options?: GetReactions) => string;
+    CHANNEL_FOLLOW: (channelId: BigString) => string;
+    CHANNEL_MESSAGE_CROSSPOST: (channelId: BigString, messageId: BigString) => string;
+    CHANNEL_OVERWRITE: (channelId: BigString, overwriteId: BigString) => string;
+    CHANNEL_TYPING: (channelId: BigString) => string;
+    THREAD_START_PUBLIC: (channelId: BigString, messageId: BigString) => string;
+    THREAD_START_PRIVATE: (channelId: BigString) => string;
+    THREAD_ACTIVE: (guildId: BigString) => string;
+    THREAD_MEMBERS: (channelId: BigString) => string;
+    THREAD_ME: (channelId: BigString) => string;
+    THREAD_USER: (channelId: BigString, userId: BigString) => string;
+    THREAD_ARCHIVED: (channelId: BigString) => string;
+    THREAD_ARCHIVED_PUBLIC: (channelId: BigString, options?: ListArchivedThreads) => string;
+    THREAD_ARCHIVED_PRIVATE: (channelId: BigString, options?: ListArchivedThreads) => string;
+    THREAD_ARCHIVED_PRIVATE_JOINED: (channelId: BigString, options?: ListArchivedThreads) => string;
+    FORUM_START: (channelId: BigString) => string;
+    GUILD: (guildId: BigString, withCounts?: boolean) => string;
+    GUILDS: () => string;
+    GUILD_AUDIT_LOGS: (guildId: BigString, options?: GetGuildAuditLog) => string;
+    GUILD_BAN: (guildId: BigString, userId: BigString) => string;
+    GUILD_BANS: (guildId: BigString, options?: GetBans) => string;
+    GUILD_BANNER: (guildId: BigString, icon: string) => string;
+    GUILD_CHANNELS: (guildId: BigString) => string;
+    GUILD_WIDGET: (guildId: BigString) => string;
+    GUILD_WIDGET_JSON: (guildId: BigString) => string;
+    GUILD_WIDGET_IMAGE: (guildId: BigString, style?: 'shield' | 'banner1' | 'banner2' | 'banner3' | 'banner4') => string;
+    GUILD_EMOJI: (guildId: BigString, emojiId: BigString) => string;
+    GUILD_EMOJIS: (guildId: BigString) => string;
+    GUILD_ICON: (guildId: BigString, icon: string) => string;
+    GUILD_INTEGRATION: (guildId: BigString, integrationId: BigString) => string;
+    GUILD_INTEGRATION_SYNC: (guildId: BigString, integrationId: BigString) => string;
+    GUILD_INTEGRATIONS: (guildId: BigString) => string;
+    GUILD_INVITES: (guildId: BigString) => string;
+    GUILD_LEAVE: (guildId: BigString) => string;
+    GUILD_MEMBER: (guildId: BigString, userId: BigString) => string;
+    GUILD_MEMBERS: (guildId: BigString, options?: ListGuildMembers) => string;
+    GUILD_MEMBER_ROLE: (guildId: BigString, memberId: BigString, roleId: BigString) => string;
+    GUILD_MEMBERS_SEARCH: (guildId: BigString, query: string, options?: {
+        limit?: number;
+    }) => string;
+    GUILD_PRUNE: (guildId: BigString, options?: GetGuildPruneCountQuery) => string;
+    GUILD_REGIONS: (guildId: BigString) => string;
+    GUILD_ROLE: (guildId: BigString, roleId: BigString) => string;
+    GUILD_ROLES: (guildId: BigString) => string;
+    GUILD_SPLASH: (guildId: BigString, icon: string) => string;
+    GUILD_VANITY_URL: (guildId: BigString) => string;
+    GUILD_WEBHOOKS: (guildId: BigString) => string;
+    TEMPLATE: (code: string) => string;
+    GUILD_TEMPLATE: (guildId: BigString, code: string) => string;
+    GUILD_TEMPLATES: (guildId: BigString) => string;
+    GUILD_PREVIEW: (guildId: BigString) => string;
+    UPDATE_VOICE_STATE: (guildId: BigString, userId?: BigString) => string;
+    GUILD_WELCOME_SCREEN: (guildId: BigString) => string;
+    GUILD_SCHEDULED_EVENTS: (guildId: BigString, withUserCount?: boolean) => string;
+    GUILD_SCHEDULED_EVENT: (guildId: BigString, eventId: BigString, withUserCount?: boolean) => string;
+    GUILD_SCHEDULED_EVENT_USERS: (guildId: BigString, eventId: BigString, options?: GetScheduledEventUsers) => string;
+    GUILD_MFA_LEVEL: (guildId: BigString) => string;
+    VOICE_REGIONS: () => string;
+    INVITE: (inviteCode: string, options?: GetInvite) => string;
+    WEBHOOK: (webhookId: BigString, token: string, options?: {
+        wait?: boolean;
+        threadId?: BigString;
+    }) => string;
+    WEBHOOK_ID: (webhookId: BigString) => string;
+    WEBHOOK_MESSAGE: (webhookId: BigString, token: string, messageId: BigString, options?: {
+        threadId?: BigString;
+    }) => string;
+    WEBHOOK_MESSAGE_ORIGINAL: (webhookId: BigString, token: string, options?: {
+        threadId?: BigString;
+    }) => string;
+    WEBHOOK_SLACK: (webhookId: BigString, token: string) => string;
+    WEBHOOK_GITHUB: (webhookId: BigString, token: string) => string;
+    COMMANDS: (applicationId: BigString) => string;
+    COMMANDS_GUILD: (applicationId: BigString, guildId: BigString) => string;
+    COMMANDS_PERMISSIONS: (applicationId: BigString, guildId: BigString) => string;
+    COMMANDS_PERMISSION: (applicationId: BigString, guildId: BigString, commandId: BigString) => string;
+    COMMANDS_ID: (applicationId: BigString, commandId: BigString, withLocalizations?: boolean) => string;
+    COMMANDS_GUILD_ID: (applicationId: BigString, guildId: BigString, commandId: BigString, withLocalizations?: boolean) => string;
+    INTERACTION_ID_TOKEN: (interactionId: BigString, token: string) => string;
+    INTERACTION_ORIGINAL_ID_TOKEN: (interactionId: BigString, token: string) => string;
+    INTERACTION_ID_TOKEN_MESSAGE_ID: (applicationId: BigString, token: string, messageId: BigString) => string;
+    USER: (userId: BigString) => string;
+    USER_BOT: () => string;
+    USER_GUILDS: () => string;
+    USER_AVATAR: (userId: BigString, icon: string) => string;
+    USER_DEFAULT_AVATAR: (icon: number) => string;
+    USER_DM: () => string;
+    USER_CONNECTIONS: () => string;
+    USER_NICK: (guildId: BigString) => string;
+    DISCOVERY_CATEGORIES: () => string;
+    DISCOVERY_VALID_TERM: (term: string) => string;
+    DISCOVERY_METADATA: (guildId: BigString) => string;
+    DISCOVERY_SUBCATEGORY: (guildId: BigString, categoryId: number) => string;
+    OAUTH2_APPLICATION: () => string;
+    STAGE_INSTANCES: () => string;
+    STAGE_INSTANCE: (channelId: BigString) => string;
+    NITRO_STICKER_PACKS: () => string;
+    STICKER: (stickerId: bigint) => string;
+    GUILD_STICKERS: (guildId: bigint) => string;
+    GUILD_STICKER: (guildId: bigint, stickerId: bigint) => string;
+};
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"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"}

package/dist/routes.js

@@ -0,0 +1,2 @@
+import{baseEndpoints as e}from"@discordeno/utils";import{isGetMessagesAfter as s,isGetMessagesAround as i,isGetMessagesBefore as t,isGetMessagesLimit as r}from"./helpers/index.js";export const routes={GATEWAY_BOT:()=>"/gateway/bot",AUTOMOD_RULES:e=>`/guilds/${e}/auto-moderation/rules`,AUTOMOD_RULE:(e,s)=>`/guilds/${e}/auto-moderation/rules/${s}`,CHANNEL:e=>`/channels/${e}`,CHANNEL_MESSAGE:(e,s)=>`/channels/${e}/messages/${s}`,CHANNEL_MESSAGES:(e,n)=>{let $=`/channels/${e}/messages?`;return n&&(s(n)&&n.after&&($+=`after=${n.after}`),t(n)&&n.before&&($+=`&before=${n.before}`),i(n)&&n.around&&($+=`&around=${n.around}`),r(n)&&n.limit&&($+=`&limit=${n.limit}`)),$},CHANNEL_PIN:(e,s)=>`/channels/${e}/pins/${s}`,CHANNEL_PINS:e=>`/channels/${e}/pins`,CHANNEL_BULK_DELETE:e=>`/channels/${e}/messages/bulk-delete`,CHANNEL_INVITES:e=>`/channels/${e}/invites`,CHANNEL_WEBHOOKS:e=>`/channels/${e}/webhooks`,CHANNEL_MESSAGE_REACTION_ME:(e,s,i)=>`/channels/${e}/messages/${s}/reactions/${encodeURIComponent(i)}/@me`,CHANNEL_MESSAGE_REACTION_USER:(e,s,i,t)=>`/channels/${e}/messages/${s}/reactions/${encodeURIComponent(i)}/${t}`,CHANNEL_MESSAGE_REACTIONS:(e,s)=>`/channels/${e}/messages/${s}/reactions`,CHANNEL_MESSAGE_REACTION:(e,s,i,t)=>{let r=`/channels/${e}/messages/${s}/reactions/${encodeURIComponent(i)}?`;return t&&(t.after&&(r+=`after=${t.after}`),t.limit&&(r+=`&limit=${t.limit}`)),r},CHANNEL_FOLLOW:e=>`/channels/${e}/followers`,CHANNEL_MESSAGE_CROSSPOST:(e,s)=>`/channels/${e}/messages/${s}/crosspost`,CHANNEL_OVERWRITE:(e,s)=>`/channels/${e}/permissions/${s}`,CHANNEL_TYPING:e=>`/channels/${e}/typing`,THREAD_START_PUBLIC:(e,s)=>`/channels/${e}/messages/${s}/threads`,THREAD_START_PRIVATE:e=>`/channels/${e}/threads`,THREAD_ACTIVE:e=>`/guilds/${e}/threads/active`,THREAD_MEMBERS:e=>`/channels/${e}/thread-members`,THREAD_ME:e=>`/channels/${e}/thread-members/@me`,THREAD_USER:(e,s)=>`/channels/${e}/thread-members/${s}`,THREAD_ARCHIVED:e=>`/channels/${e}/threads/archived`,THREAD_ARCHIVED_PUBLIC:(e,s)=>{let i=`/channels/${e}/threads/archived/public?`;return s&&(s.before&&(i+=`before=${new Date(s.before).toISOString()}`),s.limit&&(i+=`&limit=${s.limit}`)),i},THREAD_ARCHIVED_PRIVATE:(e,s)=>{let i=`/channels/${e}/threads/archived/private?`;return s&&(s.before&&(i+=`before=${new Date(s.before).toISOString()}`),s.limit&&(i+=`&limit=${s.limit}`)),i},THREAD_ARCHIVED_PRIVATE_JOINED:(e,s)=>{let i=`/channels/${e}/users/@me/threads/archived/private?`;return s&&(s.before&&(i+=`before=${new Date(s.before).toISOString()}`),s.limit&&(i+=`&limit=${s.limit}`)),i},FORUM_START:e=>`/channels/${e}/threads?has_message=true`,GUILD:(e,s)=>{let i=`/guilds/${e}?`;return void 0!==s&&(i+=`with_counts=${s.toString()}`),i},GUILDS:()=>"/guilds",GUILD_AUDIT_LOGS:(e,s)=>{let i=`/guilds/${e}/audit-logs?`;return s&&(s.actionType&&(i+=`action_type=${s.actionType}`),s.before&&(i+=`&before=${s.before}`),s.limit&&(i+=`&limit=${s.limit}`),s.userId&&(i+=`&user_id=${s.userId}`)),i},GUILD_BAN:(e,s)=>`/guilds/${e}/bans/${s}`,GUILD_BANS:(e,s)=>{let i=`/guilds/${e}/bans?`;return s&&(s.limit&&(i+=`limit=${s.limit}`),s.after&&(i+=`&after=${s.after}`),s.before&&(i+=`&before=${s.before}`)),i},GUILD_BANNER:(s,i)=>`${e.CDN_URL}/banners/${s}/${i}`,GUILD_CHANNELS:e=>`/guilds/${e}/channels`,GUILD_WIDGET:e=>`/guilds/${e}/widget`,GUILD_WIDGET_JSON:e=>`/guilds/${e}/widget.json`,GUILD_WIDGET_IMAGE:(e,s)=>{let i=`/guilds/${e}/widget.png?`;return s&&(i+=`style=${s}`),i},GUILD_EMOJI:(e,s)=>`/guilds/${e}/emojis/${s}`,GUILD_EMOJIS:e=>`/guilds/${e}/emojis`,GUILD_ICON:(s,i)=>`${e.CDN_URL}/icons/${s}/${i}`,GUILD_INTEGRATION:(e,s)=>`/guilds/${e}/integrations/${s}`,GUILD_INTEGRATION_SYNC:(e,s)=>`/guilds/${e}/integrations/${s}/sync`,GUILD_INTEGRATIONS:e=>`/guilds/${e}/integrations?include_applications=true`,GUILD_INVITES:e=>`/guilds/${e}/invites`,GUILD_LEAVE:e=>`/users/@me/guilds/${e}`,GUILD_MEMBER:(e,s)=>`/guilds/${e}/members/${s}`,GUILD_MEMBERS:(e,s)=>{let i=`/guilds/${e}/members?`;return void 0!==s&&(s.limit&&(i+=`limit=${s.limit}`),s.after&&(i+=`&after=${s.after}`)),i},GUILD_MEMBER_ROLE:(e,s,i)=>`/guilds/${e}/members/${s}/roles/${i}`,GUILD_MEMBERS_SEARCH:(e,s,i)=>{let t=`/guilds/${e}/members/search?query=${encodeURIComponent(s)}`;return i&&void 0!==i.limit&&(t+=`&limit=${i.limit}`),t},GUILD_PRUNE:(e,s)=>{let i=`/guilds/${e}/prune?`;return s&&(s.days&&(i+=`days=${s.days}`),Array.isArray(s.includeRoles)?i+=`&include_roles=${s.includeRoles.join(",")}`:s.includeRoles&&(i+=`&include_roles=${s.includeRoles}`)),i},GUILD_REGIONS:e=>`/guilds/${e}/regions`,GUILD_ROLE:(e,s)=>`/guilds/${e}/roles/${s}`,GUILD_ROLES:e=>`/guilds/${e}/roles`,GUILD_SPLASH:(s,i)=>`${e.CDN_URL}/splashes/${s}/${i}`,GUILD_VANITY_URL:e=>`/guilds/${e}/vanity-url`,GUILD_WEBHOOKS:e=>`/guilds/${e}/webhooks`,TEMPLATE:e=>`/guilds/templates/${e}`,GUILD_TEMPLATE:(e,s)=>`/guilds/${e}/templates/${s}`,GUILD_TEMPLATES:e=>`/guilds/${e}/templates`,GUILD_PREVIEW:e=>`/guilds/${e}/preview`,UPDATE_VOICE_STATE:(e,s)=>`/guilds/${e}/voice-states/${s??"@me"}`,GUILD_WELCOME_SCREEN:e=>`/guilds/${e}/welcome-screen`,GUILD_SCHEDULED_EVENTS:(e,s)=>{let i=`/guilds/${e}/scheduled-events?`;return void 0!==s&&(i+=`with_user_count=${s.toString()}`),i},GUILD_SCHEDULED_EVENT:(e,s,i)=>{let t=`/guilds/${e}/scheduled-events/${s}`;return void 0!==i&&(t+=`with_user_count=${i.toString()}`),t},GUILD_SCHEDULED_EVENT_USERS:(e,s,i)=>{let t=`/guilds/${e}/scheduled-events/${s}/users?`;return i&&(void 0!==i.limit&&(t+=`limit=${i.limit}`),void 0!==i.withMember&&(t+=`&with_member=${i.withMember.toString()}`),void 0!==i.after&&(t+=`&after=${i.after}`),void 0!==i.before&&(t+=`&before=${i.before}`)),t},GUILD_MFA_LEVEL:e=>`/guilds/${e}/mfa`,VOICE_REGIONS:()=>"/voice/regions",INVITE:(e,s)=>{let i=`/invites/${e}?`;return s&&(void 0!==s.withCounts&&(i+=`with_counts=${s.withCounts.toString()}`),void 0!==s.withExpiration&&(i+=`&with_expiration=${s.withExpiration.toString()}`),s.scheduledEventId&&(i+=`&guild_scheduled_event_id=${s.scheduledEventId}`)),i},WEBHOOK:(e,s,i)=>{let t=`/webhooks/${e}/${s}?`;return i&&(i?.wait!==void 0&&(t+=`wait=${i.wait.toString()}`),i.threadId&&(t+=`thread_id=${i.threadId}`)),t},WEBHOOK_ID:e=>`/webhooks/${e}`,WEBHOOK_MESSAGE:(e,s,i,t)=>{let r=`/webhooks/${e}/${s}/messages/${i}?`;return t&&t.threadId&&(r+=`thread_id=${t.threadId}`),r},WEBHOOK_MESSAGE_ORIGINAL:(e,s,i)=>{let t=`/webhooks/${e}/${s}/messages/@original?`;return i&&i.threadId&&(t+=`thread_id=${i.threadId}`),t},WEBHOOK_SLACK:(e,s)=>`/webhooks/${e}/${s}/slack`,WEBHOOK_GITHUB:(e,s)=>`/webhooks/${e}/${s}/github`,COMMANDS:e=>`/applications/${e}/commands`,COMMANDS_GUILD:(e,s)=>`/applications/${e}/guilds/${s}/commands`,COMMANDS_PERMISSIONS:(e,s)=>`/applications/${e}/guilds/${s}/commands/permissions`,COMMANDS_PERMISSION:(e,s,i)=>`/applications/${e}/guilds/${s}/commands/${i}/permissions`,COMMANDS_ID:(e,s,i)=>{let t=`/applications/${e}/commands/${s}?`;return void 0!==i&&(t+=`withLocalizations=${i.toString()}`),t},COMMANDS_GUILD_ID:(e,s,i,t)=>{let r=`/applications/${e}/guilds/${s}/commands/${i}?`;return void 0!==t&&(r+=`with_localizations=${t.toString()}`),r},INTERACTION_ID_TOKEN:(e,s)=>`/interactions/${e}/${s}/callback`,INTERACTION_ORIGINAL_ID_TOKEN:(e,s)=>`/webhooks/${e}/${s}/messages/@original`,INTERACTION_ID_TOKEN_MESSAGE_ID:(e,s,i)=>`/webhooks/${e}/${s}/messages/${i}`,USER:e=>`/users/${e}`,USER_BOT:()=>"/users/@me",USER_GUILDS:()=>"/users/@me/guilds",USER_AVATAR:(s,i)=>`${e.CDN_URL}/avatars/${s}/${i}`,USER_DEFAULT_AVATAR:s=>`${e.CDN_URL}/embed/avatars/${s}.png`,USER_DM:()=>"/users/@me/channels",USER_CONNECTIONS:()=>"/users/@me/connections",USER_NICK:e=>`/guilds/${e}/members/@me`,DISCOVERY_CATEGORIES:()=>"/discovery/categories",DISCOVERY_VALID_TERM:e=>`/discovery/valid-term?term=${e}`,DISCOVERY_METADATA:e=>`/guilds/${e}/discovery-metadata`,DISCOVERY_SUBCATEGORY:(e,s)=>`/guilds/${e}/discovery-categories/${s}`,OAUTH2_APPLICATION:()=>"oauth2/applications/@me",STAGE_INSTANCES:()=>"/stage-instances",STAGE_INSTANCE:e=>`/stage-instances/${e}`,NITRO_STICKER_PACKS:()=>"/sticker-packs",STICKER:e=>`/stickers/${e}`,GUILD_STICKERS:e=>`/guilds/${e}/stickers`,GUILD_STICKER:(e,s)=>`/guilds/${e}/stickers/${s}`};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/routes.ts"],"sourcesContent":["import { BigString } from '@discordeno/types'\nimport { baseEndpoints } from '@discordeno/utils'\nimport {\n  GetBans,\n  GetGuildAuditLog,\n  GetGuildPruneCountQuery,\n  GetInvite,\n  GetMessagesOptions,\n  GetReactions,\n  GetScheduledEventUsers,\n  isGetMessagesAfter,\n  isGetMessagesAround,\n  isGetMessagesBefore,\n  isGetMessagesLimit,\n  ListArchivedThreads,\n  ListGuildMembers\n} from './helpers/index.js'\n\nexport const routes = {\n  GATEWAY_BOT: () => {\n    return '/gateway/bot'\n  },\n\n  // Automod Endpoints\n  AUTOMOD_RULES: (guildId: BigString) => {\n    return `/guilds/${guildId}/auto-moderation/rules`\n  },\n  AUTOMOD_RULE: (guildId: BigString, ruleId: BigString) => {\n    return `/guilds/${guildId}/auto-moderation/rules/${ruleId}`\n  },\n\n  // Channel Endpoints\n  CHANNEL: (channelId: BigString) => {\n    return `/channels/${channelId}`\n  },\n  CHANNEL_MESSAGE: (channelId: BigString, messageId: BigString) => {\n    return `/channels/${channelId}/messages/${messageId}`\n  },\n  CHANNEL_MESSAGES: (channelId: BigString, options?: GetMessagesOptions) => {\n    let url = `/channels/${channelId}/messages?`\n\n    if (options) {\n      if (isGetMessagesAfter(options) && options.after) {\n        url += `after=${options.after}`\n      }\n      if (isGetMessagesBefore(options) && options.before) {\n        url += `&before=${options.before}`\n      }\n      if (isGetMessagesAround(options) && options.around) {\n        url += `&around=${options.around}`\n      }\n      if (isGetMessagesLimit(options) && options.limit) {\n        url += `&limit=${options.limit}`\n      }\n    }\n\n    return url\n  },\n  CHANNEL_PIN: (channelId: BigString, messageId: BigString) => {\n    return `/channels/${channelId}/pins/${messageId}`\n  },\n  CHANNEL_PINS: (channelId: BigString) => {\n    return `/channels/${channelId}/pins`\n  },\n  CHANNEL_BULK_DELETE: (channelId: BigString) => {\n    return `/channels/${channelId}/messages/bulk-delete`\n  },\n  CHANNEL_INVITES: (channelId: BigString) => {\n    return `/channels/${channelId}/invites`\n  },\n  CHANNEL_WEBHOOKS: (channelId: BigString) => {\n    return `/channels/${channelId}/webhooks`\n  },\n  CHANNEL_MESSAGE_REACTION_ME: (\n    channelId: BigString,\n    messageId: BigString,\n    emoji: string\n  ) => {\n    return `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(\n      emoji\n    )}/@me`\n  },\n  CHANNEL_MESSAGE_REACTION_USER: (\n    channelId: BigString,\n    messageId: BigString,\n    emoji: string,\n    userId: BigString\n  ) => {\n    return `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(\n      emoji\n    )}/${userId}`\n  },\n  CHANNEL_MESSAGE_REACTIONS: (channelId: BigString, messageId: BigString) => {\n    return `/channels/${channelId}/messages/${messageId}/reactions`\n  },\n  CHANNEL_MESSAGE_REACTION: (\n    channelId: BigString,\n    messageId: BigString,\n    emoji: string,\n    options?: GetReactions\n  ) => {\n    let url = `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(\n      emoji\n    )}?`\n\n    if (options) {\n      if (options.after) url += `after=${options.after}`\n      if (options.limit) url += `&limit=${options.limit}`\n    }\n\n    return url\n  },\n  CHANNEL_FOLLOW: (channelId: BigString) => {\n    return `/channels/${channelId}/followers`\n  },\n  CHANNEL_MESSAGE_CROSSPOST: (channelId: BigString, messageId: BigString) => {\n    return `/channels/${channelId}/messages/${messageId}/crosspost`\n  },\n  CHANNEL_OVERWRITE: (channelId: BigString, overwriteId: BigString) => {\n    return `/channels/${channelId}/permissions/${overwriteId}`\n  },\n  // Bots SHALL NOT use this endpoint but they can\n  CHANNEL_TYPING: (channelId: BigString) => {\n    return `/channels/${channelId}/typing`\n  },\n\n  // Thread Endpoints\n  THREAD_START_PUBLIC: (channelId: BigString, messageId: BigString) => {\n    return `/channels/${channelId}/messages/${messageId}/threads`\n  },\n  THREAD_START_PRIVATE: (channelId: BigString) => {\n    return `/channels/${channelId}/threads`\n  },\n  THREAD_ACTIVE: (guildId: BigString) => {\n    return `/guilds/${guildId}/threads/active`\n  },\n  THREAD_MEMBERS: (channelId: BigString) => {\n    return `/channels/${channelId}/thread-members`\n  },\n  THREAD_ME: (channelId: BigString) => {\n    return `/channels/${channelId}/thread-members/@me`\n  },\n  THREAD_USER: (channelId: BigString, userId: BigString) => {\n    return `/channels/${channelId}/thread-members/${userId}`\n  },\n  THREAD_ARCHIVED: (channelId: BigString) => {\n    return `/channels/${channelId}/threads/archived`\n  },\n  THREAD_ARCHIVED_PUBLIC: (\n    channelId: BigString,\n    options?: ListArchivedThreads\n  ) => {\n    let url = `/channels/${channelId}/threads/archived/public?`\n\n    if (options) {\n      if (options.before) {\n        url += `before=${new Date(options.before).toISOString()}`\n      }\n      if (options.limit) url += `&limit=${options.limit}`\n    }\n\n    return url\n  },\n  THREAD_ARCHIVED_PRIVATE: (\n    channelId: BigString,\n    options?: ListArchivedThreads\n  ) => {\n    let url = `/channels/${channelId}/threads/archived/private?`\n\n    if (options) {\n      if (options.before) {\n        url += `before=${new Date(options.before).toISOString()}`\n      }\n      if (options.limit) url += `&limit=${options.limit}`\n    }\n\n    return url\n  },\n  THREAD_ARCHIVED_PRIVATE_JOINED: (\n    channelId: BigString,\n    options?: ListArchivedThreads\n  ) => {\n    let url = `/channels/${channelId}/users/@me/threads/archived/private?`\n\n    if (options) {\n      if (options.before) {\n        url += `before=${new Date(options.before).toISOString()}`\n      }\n      if (options.limit) url += `&limit=${options.limit}`\n    }\n\n    return url\n  },\n\n  // Thread -> Forum Endpoints\n  FORUM_START: (channelId: BigString) => {\n    return `/channels/${channelId}/threads?has_message=true`\n  },\n\n  // Guild Endpoints\n  GUILD: (guildId: BigString, withCounts?: boolean) => {\n    let url = `/guilds/${guildId}?`\n\n    if (withCounts !== undefined) {\n      url += `with_counts=${withCounts.toString()}`\n    }\n\n    return url\n  },\n  GUILDS: () => {\n    return '/guilds'\n  },\n  GUILD_AUDIT_LOGS: (guildId: BigString, options?: GetGuildAuditLog) => {\n    let url = `/guilds/${guildId}/audit-logs?`\n\n    if (options) {\n      if (options.actionType) url += `action_type=${options.actionType}`\n      if (options.before) url += `&before=${options.before}`\n      if (options.limit) url += `&limit=${options.limit}`\n      if (options.userId) url += `&user_id=${options.userId}`\n    }\n\n    return url\n  },\n  GUILD_BAN: (guildId: BigString, userId: BigString) => {\n    return `/guilds/${guildId}/bans/${userId}`\n  },\n  GUILD_BANS: (guildId: BigString, options?: GetBans) => {\n    let url = `/guilds/${guildId}/bans?`\n\n    if (options) {\n      if (options.limit) url += `limit=${options.limit}`\n      if (options.after) url += `&after=${options.after}`\n      if (options.before) url += `&before=${options.before}`\n    }\n\n    return url\n  },\n  // TODO: move this away\n  GUILD_BANNER: (guildId: BigString, icon: string) => {\n    return `${baseEndpoints.CDN_URL}/banners/${guildId}/${icon}`\n  },\n  GUILD_CHANNELS: (guildId: BigString) => {\n    return `/guilds/${guildId}/channels`\n  },\n  GUILD_WIDGET: (guildId: BigString) => {\n    return `/guilds/${guildId}/widget`\n  },\n  GUILD_WIDGET_JSON: (guildId: BigString) => {\n    return `/guilds/${guildId}/widget.json`\n  },\n  GUILD_WIDGET_IMAGE: (\n    guildId: BigString,\n    style?: 'shield' | 'banner1' | 'banner2' | 'banner3' | 'banner4'\n  ) => {\n    let url = `/guilds/${guildId}/widget.png?`\n\n    if (style) {\n      url += `style=${style}`\n    }\n\n    return url\n  },\n  GUILD_EMOJI: (guildId: BigString, emojiId: BigString) => {\n    return `/guilds/${guildId}/emojis/${emojiId}`\n  },\n  GUILD_EMOJIS: (guildId: BigString) => {\n    return `/guilds/${guildId}/emojis`\n  },\n  // TODO: move this away\n  GUILD_ICON: (guildId: BigString, icon: string) => {\n    return `${baseEndpoints.CDN_URL}/icons/${guildId}/${icon}`\n  },\n  GUILD_INTEGRATION: (guildId: BigString, integrationId: BigString) => {\n    return `/guilds/${guildId}/integrations/${integrationId}`\n  },\n  GUILD_INTEGRATION_SYNC: (guildId: BigString, integrationId: BigString) => {\n    return `/guilds/${guildId}/integrations/${integrationId}/sync`\n  },\n  GUILD_INTEGRATIONS: (guildId: BigString) => {\n    return `/guilds/${guildId}/integrations?include_applications=true`\n  },\n  GUILD_INVITES: (guildId: BigString) => {\n    return `/guilds/${guildId}/invites`\n  },\n  GUILD_LEAVE: (guildId: BigString) => {\n    return `/users/@me/guilds/${guildId}`\n  },\n  GUILD_MEMBER: (guildId: BigString, userId: BigString) => {\n    return `/guilds/${guildId}/members/${userId}`\n  },\n  GUILD_MEMBERS: (guildId: BigString, options?: ListGuildMembers) => {\n    let url = `/guilds/${guildId}/members?`\n\n    if (options !== undefined) {\n      if (options.limit) url += `limit=${options.limit}`\n      if (options.after) url += `&after=${options.after}`\n    }\n\n    return url\n  },\n  GUILD_MEMBER_ROLE: (\n    guildId: BigString,\n    memberId: BigString,\n    roleId: BigString\n  ) => {\n    return `/guilds/${guildId}/members/${memberId}/roles/${roleId}`\n  },\n  GUILD_MEMBERS_SEARCH: (\n    guildId: BigString,\n    query: string,\n    options?: { limit?: number }\n  ) => {\n    let url = `/guilds/${guildId}/members/search?query=${encodeURIComponent(\n      query\n    )}`\n\n    if (options) {\n      if (options.limit !== undefined) url += `&limit=${options.limit}`\n    }\n\n    return url\n  },\n  GUILD_PRUNE: (guildId: BigString, options?: GetGuildPruneCountQuery) => {\n    let url = `/guilds/${guildId}/prune?`\n\n    if (options) {\n      if (options.days) url += `days=${options.days}`\n      if (Array.isArray(options.includeRoles)) {\n        url += `&include_roles=${options.includeRoles.join(',')}`\n      } else if (options.includeRoles) {\n        url += `&include_roles=${options.includeRoles}`\n      }\n    }\n\n    return url\n  },\n  GUILD_REGIONS: (guildId: BigString) => {\n    return `/guilds/${guildId}/regions`\n  },\n  GUILD_ROLE: (guildId: BigString, roleId: BigString) => {\n    return `/guilds/${guildId}/roles/${roleId}`\n  },\n  GUILD_ROLES: (guildId: BigString) => {\n    return `/guilds/${guildId}/roles`\n  },\n  // TODO: move this away\n  GUILD_SPLASH: (guildId: BigString, icon: string) => {\n    return `${baseEndpoints.CDN_URL}/splashes/${guildId}/${icon}`\n  },\n  GUILD_VANITY_URL: (guildId: BigString) => {\n    return `/guilds/${guildId}/vanity-url`\n  },\n  GUILD_WEBHOOKS: (guildId: BigString) => {\n    return `/guilds/${guildId}/webhooks`\n  },\n  TEMPLATE: (code: string) => {\n    return `/guilds/templates/${code}`\n  },\n  GUILD_TEMPLATE: (guildId: BigString, code: string) => {\n    return `/guilds/${guildId}/templates/${code}`\n  },\n  GUILD_TEMPLATES: (guildId: BigString) => {\n    return `/guilds/${guildId}/templates`\n  },\n  GUILD_PREVIEW: (guildId: BigString) => {\n    return `/guilds/${guildId}/preview`\n  },\n  UPDATE_VOICE_STATE: (guildId: BigString, userId?: BigString) => {\n    return `/guilds/${guildId}/voice-states/${userId ?? '@me'}`\n  },\n  GUILD_WELCOME_SCREEN: (guildId: BigString) => {\n    return `/guilds/${guildId}/welcome-screen`\n  },\n  GUILD_SCHEDULED_EVENTS: (guildId: BigString, withUserCount?: boolean) => {\n    let url = `/guilds/${guildId}/scheduled-events?`\n\n    if (withUserCount !== undefined) {\n      url += `with_user_count=${withUserCount.toString()}`\n    }\n    return url\n  },\n  GUILD_SCHEDULED_EVENT: (\n    guildId: BigString,\n    eventId: BigString,\n    withUserCount?: boolean\n  ) => {\n    let url = `/guilds/${guildId}/scheduled-events/${eventId}`\n\n    if (withUserCount !== undefined) {\n      url += `with_user_count=${withUserCount.toString()}`\n    }\n\n    return url\n  },\n  GUILD_SCHEDULED_EVENT_USERS: (\n    guildId: BigString,\n    eventId: BigString,\n    options?: GetScheduledEventUsers\n  ) => {\n    let url = `/guilds/${guildId}/scheduled-events/${eventId}/users?`\n\n    if (options) {\n      if (options.limit !== undefined) url += `limit=${options.limit}`\n      if (options.withMember !== undefined) {\n        url += `&with_member=${options.withMember.toString()}`\n      }\n      if (options.after !== undefined) url += `&after=${options.after}`\n      if (options.before !== undefined) url += `&before=${options.before}`\n    }\n\n    return url\n  },\n  GUILD_MFA_LEVEL: (guildId: BigString) => `/guilds/${guildId}/mfa`,\n  // Voice\n  VOICE_REGIONS: () => {\n    return '/voice/regions'\n  },\n\n  INVITE: (inviteCode: string, options?: GetInvite) => {\n    let url = `/invites/${inviteCode}?`\n\n    if (options) {\n      if (options.withCounts !== undefined) {\n        url += `with_counts=${options.withCounts.toString()}`\n      }\n      if (options.withExpiration !== undefined) {\n        url += `&with_expiration=${options.withExpiration.toString()}`\n      }\n      if (options.scheduledEventId) {\n        url += `&guild_scheduled_event_id=${options.scheduledEventId}`\n      }\n    }\n\n    return url\n  },\n\n  WEBHOOK: (\n    webhookId: BigString,\n    token: string,\n    options?: { wait?: boolean, threadId?: BigString }\n  ) => {\n    let url = `/webhooks/${webhookId}/${token}?`\n\n    if (options) {\n      if (options?.wait !== undefined) url += `wait=${options.wait.toString()}`\n      if (options.threadId) url += `thread_id=${options.threadId}`\n    }\n\n    return url\n  },\n  WEBHOOK_ID: (webhookId: BigString) => {\n    return `/webhooks/${webhookId}`\n  },\n  WEBHOOK_MESSAGE: (\n    webhookId: BigString,\n    token: string,\n    messageId: BigString,\n    options?: { threadId?: BigString }\n  ) => {\n    let url = `/webhooks/${webhookId}/${token}/messages/${messageId}?`\n\n    if (options) {\n      if (options.threadId) url += `thread_id=${options.threadId}`\n    }\n\n    return url\n  },\n  WEBHOOK_MESSAGE_ORIGINAL: (\n    webhookId: BigString,\n    token: string,\n    options?: { threadId?: BigString }\n  ) => {\n    let url = `/webhooks/${webhookId}/${token}/messages/@original?`\n\n    if (options) {\n      if (options.threadId) url += `thread_id=${options.threadId}`\n    }\n\n    return url\n  },\n  WEBHOOK_SLACK: (webhookId: BigString, token: string) => {\n    return `/webhooks/${webhookId}/${token}/slack`\n  },\n  WEBHOOK_GITHUB: (webhookId: BigString, token: string) => {\n    return `/webhooks/${webhookId}/${token}/github`\n  },\n\n  // Application Endpoints\n  COMMANDS: (applicationId: BigString) => {\n    return `/applications/${applicationId}/commands`\n  },\n  COMMANDS_GUILD: (applicationId: BigString, guildId: BigString) => {\n    return `/applications/${applicationId}/guilds/${guildId}/commands`\n  },\n  COMMANDS_PERMISSIONS: (applicationId: BigString, guildId: BigString) => {\n    return `/applications/${applicationId}/guilds/${guildId}/commands/permissions`\n  },\n  COMMANDS_PERMISSION: (\n    applicationId: BigString,\n    guildId: BigString,\n    commandId: BigString\n  ) => {\n    return `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`\n  },\n  COMMANDS_ID: (\n    applicationId: BigString,\n    commandId: BigString,\n    withLocalizations?: boolean\n  ) => {\n    let url = `/applications/${applicationId}/commands/${commandId}?`\n\n    if (withLocalizations !== undefined) {\n      url += `withLocalizations=${withLocalizations.toString()}`\n    }\n\n    return url\n  },\n  COMMANDS_GUILD_ID: (\n    applicationId: BigString,\n    guildId: BigString,\n    commandId: BigString,\n    withLocalizations?: boolean\n  ) => {\n    let url = `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}?`\n\n    if (withLocalizations !== undefined) {\n      url += `with_localizations=${withLocalizations.toString()}`\n    }\n\n    return url\n  },\n\n  // Interaction Endpoints\n  INTERACTION_ID_TOKEN: (interactionId: BigString, token: string) => {\n    return `/interactions/${interactionId}/${token}/callback`\n  },\n  INTERACTION_ORIGINAL_ID_TOKEN: (interactionId: BigString, token: string) => {\n    return `/webhooks/${interactionId}/${token}/messages/@original`\n  },\n  INTERACTION_ID_TOKEN_MESSAGE_ID: (\n    applicationId: BigString,\n    token: string,\n    messageId: BigString\n  ) => {\n    return `/webhooks/${applicationId}/${token}/messages/${messageId}`\n  },\n\n  // User endpoints\n  USER: (userId: BigString) => {\n    return `/users/${userId}`\n  },\n  USER_BOT: () => {\n    return '/users/@me'\n  },\n  USER_GUILDS: () => {\n    return '/users/@me/guilds'\n  },\n  // TODO: move this away\n  USER_AVATAR: (userId: BigString, icon: string) => {\n    return `${baseEndpoints.CDN_URL}/avatars/${userId}/${icon}`\n  },\n  // TODO: move this away\n  USER_DEFAULT_AVATAR: (icon: number) => {\n    return `${baseEndpoints.CDN_URL}/embed/avatars/${icon}.png`\n  },\n  USER_DM: () => {\n    return '/users/@me/channels'\n  },\n  USER_CONNECTIONS: () => {\n    return '/users/@me/connections'\n  },\n  USER_NICK: (guildId: BigString) => {\n    return `/guilds/${guildId}/members/@me`\n  },\n\n  // Discovery Endpoints\n  DISCOVERY_CATEGORIES: () => {\n    return '/discovery/categories'\n  },\n  DISCOVERY_VALID_TERM: (term: string) => {\n    return `/discovery/valid-term?term=${term}`\n  },\n  DISCOVERY_METADATA: (guildId: BigString) => {\n    return `/guilds/${guildId}/discovery-metadata`\n  },\n  DISCOVERY_SUBCATEGORY: (guildId: BigString, categoryId: number) => {\n    return `/guilds/${guildId}/discovery-categories/${categoryId}`\n  },\n\n  // OAuth2\n  OAUTH2_APPLICATION: () => {\n    return 'oauth2/applications/@me'\n  },\n\n  // Stage instances\n  STAGE_INSTANCES: () => {\n    return '/stage-instances'\n  },\n  STAGE_INSTANCE: (channelId: BigString) => {\n    return `/stage-instances/${channelId}`\n  },\n\n  // Stickers Endpoints\n  NITRO_STICKER_PACKS: () => {\n    return '/sticker-packs'\n  },\n  STICKER: (stickerId: bigint) => {\n    return `/stickers/${stickerId}`\n  },\n  GUILD_STICKERS: (guildId: bigint) => {\n    return `/guilds/${guildId}/stickers`\n  },\n  GUILD_STICKER: (guildId: bigint, stickerId: bigint) => {\n    return `/guilds/${guildId}/stickers/${stickerId}`\n  }\n}\n"],"names":["baseEndpoints","isGetMessagesAfter","isGetMessagesAround","isGetMessagesBefore","isGetMessagesLimit","routes","GATEWAY_BOT","AUTOMOD_RULES","guildId","AUTOMOD_RULE","ruleId","CHANNEL","channelId","CHANNEL_MESSAGE","messageId","CHANNEL_MESSAGES","options","url","after","before","around","limit","CHANNEL_PIN","CHANNEL_PINS","CHANNEL_BULK_DELETE","CHANNEL_INVITES","CHANNEL_WEBHOOKS","CHANNEL_MESSAGE_REACTION_ME","emoji","encodeURIComponent","CHANNEL_MESSAGE_REACTION_USER","userId","CHANNEL_MESSAGE_REACTIONS","CHANNEL_MESSAGE_REACTION","CHANNEL_FOLLOW","CHANNEL_MESSAGE_CROSSPOST","CHANNEL_OVERWRITE","overwriteId","CHANNEL_TYPING","THREAD_START_PUBLIC","THREAD_START_PRIVATE","THREAD_ACTIVE","THREAD_MEMBERS","THREAD_ME","THREAD_USER","THREAD_ARCHIVED","THREAD_ARCHIVED_PUBLIC","Date","toISOString","THREAD_ARCHIVED_PRIVATE","THREAD_ARCHIVED_PRIVATE_JOINED","FORUM_START","GUILD","withCounts","undefined","toString","GUILDS","GUILD_AUDIT_LOGS","actionType","GUILD_BAN","GUILD_BANS","GUILD_BANNER","icon","CDN_URL","GUILD_CHANNELS","GUILD_WIDGET","GUILD_WIDGET_JSON","GUILD_WIDGET_IMAGE","style","GUILD_EMOJI","emojiId","GUILD_EMOJIS","GUILD_ICON","GUILD_INTEGRATION","integrationId","GUILD_INTEGRATION_SYNC","GUILD_INTEGRATIONS","GUILD_INVITES","GUILD_LEAVE","GUILD_MEMBER","GUILD_MEMBERS","GUILD_MEMBER_ROLE","memberId","roleId","GUILD_MEMBERS_SEARCH","query","GUILD_PRUNE","days","Array","isArray","includeRoles","join","GUILD_REGIONS","GUILD_ROLE","GUILD_ROLES","GUILD_SPLASH","GUILD_VANITY_URL","GUILD_WEBHOOKS","TEMPLATE","code","GUILD_TEMPLATE","GUILD_TEMPLATES","GUILD_PREVIEW","UPDATE_VOICE_STATE","GUILD_WELCOME_SCREEN","GUILD_SCHEDULED_EVENTS","withUserCount","GUILD_SCHEDULED_EVENT","eventId","GUILD_SCHEDULED_EVENT_USERS","withMember","GUILD_MFA_LEVEL","VOICE_REGIONS","INVITE","inviteCode","withExpiration","scheduledEventId","WEBHOOK","webhookId","token","wait","threadId","WEBHOOK_ID","WEBHOOK_MESSAGE","WEBHOOK_MESSAGE_ORIGINAL","WEBHOOK_SLACK","WEBHOOK_GITHUB","COMMANDS","applicationId","COMMANDS_GUILD","COMMANDS_PERMISSIONS","COMMANDS_PERMISSION","commandId","COMMANDS_ID","withLocalizations","COMMANDS_GUILD_ID","INTERACTION_ID_TOKEN","interactionId","INTERACTION_ORIGINAL_ID_TOKEN","INTERACTION_ID_TOKEN_MESSAGE_ID","USER","USER_BOT","USER_GUILDS","USER_AVATAR","USER_DEFAULT_AVATAR","USER_DM","USER_CONNECTIONS","USER_NICK","DISCOVERY_CATEGORIES","DISCOVERY_VALID_TERM","term","DISCOVERY_METADATA","DISCOVERY_SUBCATEGORY","categoryId","OAUTH2_APPLICATION","STAGE_INSTANCES","STAGE_INSTANCE","NITRO_STICKER_PACKS","STICKER","stickerId","GUILD_STICKERS","GUILD_STICKER"],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+import { AllowedMentions, ApplicationCommandTypes, FileContent, InteractionResponseTypes, Localization, MessageComponents, PermissionStrings } from '@discordeno/types';
+import { ApplicationCommandOption } from './transformers/applicationCommandOption.js';
+import { ApplicationCommandOptionChoice } from './transformers/applicationCommandOptionChoice.js';
+import { Embed } from './transformers/embed.js';
+export type CreateApplicationCommand = CreateSlashApplicationCommand | CreateContextApplicationCommand;
+/** https://discord.com/developers/docs/interactions/application-commands#endpoints-json-params */
+export interface CreateSlashApplicationCommand {
+    /**
+     * Name of command, 1-32 characters.
+     * `ApplicationCommandTypes.ChatInput` command names must match the following regex `^[-_\p{L}\p{N}\p{sc=Deva}\p{sc=Thai}]{1,32}$` with the unicode flag set.
+     * If there is a lowercase variant of any letters used, you must use those.
+     * Characters with no lowercase variants and/or uncased letters are still allowed.
+     * ApplicationCommandTypes.User` and `ApplicationCommandTypes.Message` commands may be mixed case and can include spaces.
+     */
+    name: string;
+    /** Localization object for the `name` field. Values follow the same restrictions as `name` */
+    nameLocalizations?: Localization;
+    /** 1-100 character description */
+    description: string;
+    /** Localization object for the `description` field. Values follow the same restrictions as `description` */
+    descriptionLocalizations?: Localization;
+    /** Type of command, defaults `ApplicationCommandTypes.ChatInput` if not set  */
+    type?: ApplicationCommandTypes;
+    /** Parameters for the command */
+    options?: ApplicationCommandOption[];
+    /** Set of permissions represented as a bit set */
+    defaultMemberPermissions?: PermissionStrings[];
+    /** Indicates whether the command is available in DMs with the app, only for globally-scoped commands. By default, commands are visible. */
+    dmPermission?: boolean;
+}
+/** https://discord.com/developers/docs/interactions/application-commands#endpoints-json-params */
+export interface CreateContextApplicationCommand extends Omit<CreateSlashApplicationCommand, 'options' | 'description' | 'descriptionLocalizations'> {
+    /** The type of the command */
+    type: ApplicationCommandTypes.Message | ApplicationCommandTypes.User;
+}
+export declare function isContextApplicationCommand(command: CreateApplicationCommand): command is CreateContextApplicationCommand;
+/** https://discord.com/developers/docs/interactions/slash-commands#interaction-response-interactionapplicationcommandcallbackdata */
+export interface InteractionCallbackData {
+    /** The message contents (up to 2000 characters) */
+    content?: string;
+    /** True if this is a TTS message */
+    tts?: boolean;
+    /** Embedded `rich` content (up to 6000 characters) */
+    embeds?: Embed[];
+    /** Allowed mentions for the message */
+    allowedMentions?: AllowedMentions;
+    /** The contents of the file being sent */
+    file?: FileContent | FileContent[];
+    /** The customId you want to use for this modal response. */
+    customId?: string;
+    /** The title you want to use for this modal response. */
+    title?: string;
+    /** The components you would like to have sent in this message */
+    components?: MessageComponents;
+    /** Message flags combined as a bit field (only SUPPRESS_EMBEDS and EPHEMERAL can be set) */
+    flags?: number;
+    /** Autocomplete choices (max of 25 choices) */
+    choices?: ApplicationCommandOptionChoice[];
+}
+/** https://discord.com/developers/docs/interactions/slash-commands#interaction-response */
+export interface InteractionResponse {
+    /** The type of response */
+    type: InteractionResponseTypes;
+    /** An optional response message */
+    data?: InteractionCallbackData;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,WAAW,EACX,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAA;AACrF,OAAO,EAAE,8BAA8B,EAAE,MAAM,kDAAkD,CAAA;AACjG,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAE/C,MAAM,MAAM,wBAAwB,GAChC,6BAA6B,GAC7B,+BAA+B,CAAA;AAEnC,kGAAkG;AAClG,MAAM,WAAW,6BAA6B;IAC5C;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,8FAA8F;IAC9F,iBAAiB,CAAC,EAAE,YAAY,CAAA;IAChC,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,4GAA4G;IAC5G,wBAAwB,CAAC,EAAE,YAAY,CAAA;IACvC,gFAAgF;IAChF,IAAI,CAAC,EAAE,uBAAuB,CAAA;IAC9B,iCAAiC;IACjC,OAAO,CAAC,EAAE,wBAAwB,EAAE,CAAA;IACpC,kDAAkD;IAClD,wBAAwB,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC9C,2IAA2I;IAC3I,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,kGAAkG;AAClG,MAAM,WAAW,+BACf,SAAQ,IAAI,CACZ,6BAA6B,EAC7B,SAAS,GAAG,aAAa,GAAG,0BAA0B,CACrD;IACD,8BAA8B;IAC9B,IAAI,EAAE,uBAAuB,CAAC,OAAO,GAAG,uBAAuB,CAAC,IAAI,CAAA;CACrE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,wBAAwB,GAChC,OAAO,IAAI,+BAA+B,CAK5C;AAED,qIAAqI;AACrI,MAAM,WAAW,uBAAuB;IACtC,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oCAAoC;IACpC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,sDAAsD;IACtD,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;IAChB,uCAAuC;IACvC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,0CAA0C;IAC1C,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,CAAA;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,OAAO,CAAC,EAAE,8BAA8B,EAAE,CAAA;CAC3C;AAED,2FAA2F;AAC3F,MAAM,WAAW,mBAAmB;IAClC,2BAA2B;IAC3B,IAAI,EAAE,wBAAwB,CAAA;IAC9B,mCAAmC;IACnC,IAAI,CAAC,EAAE,uBAAuB,CAAA;CAC/B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+import{ApplicationCommandTypes as e}from"@discordeno/types";export function isContextApplicationCommand(t){return t.type===e.Message||t.type===e.User}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBBbGxvd2VkTWVudGlvbnMsXG4gIEFwcGxpY2F0aW9uQ29tbWFuZFR5cGVzLFxuICBGaWxlQ29udGVudCxcbiAgSW50ZXJhY3Rpb25SZXNwb25zZVR5cGVzLFxuICBMb2NhbGl6YXRpb24sXG4gIE1lc3NhZ2VDb21wb25lbnRzLFxuICBQZXJtaXNzaW9uU3RyaW5nc1xufSBmcm9tICdAZGlzY29yZGVuby90eXBlcydcbmltcG9ydCB7IEFwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbiB9IGZyb20gJy4vdHJhbnNmb3JtZXJzL2FwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbi5qcydcbmltcG9ydCB7IEFwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbkNob2ljZSB9IGZyb20gJy4vdHJhbnNmb3JtZXJzL2FwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbkNob2ljZS5qcydcbmltcG9ydCB7IEVtYmVkIH0gZnJvbSAnLi90cmFuc2Zvcm1lcnMvZW1iZWQuanMnXG5cbmV4cG9ydCB0eXBlIENyZWF0ZUFwcGxpY2F0aW9uQ29tbWFuZCA9XG4gIHwgQ3JlYXRlU2xhc2hBcHBsaWNhdGlvbkNvbW1hbmRcbiAgfCBDcmVhdGVDb250ZXh0QXBwbGljYXRpb25Db21tYW5kXG5cbi8qKiBodHRwczovL2Rpc2NvcmQuY29tL2RldmVsb3BlcnMvZG9jcy9pbnRlcmFjdGlvbnMvYXBwbGljYXRpb24tY29tbWFuZHMjZW5kcG9pbnRzLWpzb24tcGFyYW1zICovXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZVNsYXNoQXBwbGljYXRpb25Db21tYW5kIHtcbiAgLyoqXG4gICAqIE5hbWUgb2YgY29tbWFuZCwgMS0zMiBjaGFyYWN0ZXJzLlxuICAgKiBgQXBwbGljYXRpb25Db21tYW5kVHlwZXMuQ2hhdElucHV0YCBjb21tYW5kIG5hbWVzIG11c3QgbWF0Y2ggdGhlIGZvbGxvd2luZyByZWdleCBgXlstX1xccHtMfVxccHtOfVxccHtzYz1EZXZhfVxccHtzYz1UaGFpfV17MSwzMn0kYCB3aXRoIHRoZSB1bmljb2RlIGZsYWcgc2V0LlxuICAgKiBJZiB0aGVyZSBpcyBhIGxvd2VyY2FzZSB2YXJpYW50IG9mIGFueSBsZXR0ZXJzIHVzZWQsIHlvdSBtdXN0IHVzZSB0aG9zZS5cbiAgICogQ2hhcmFjdGVycyB3aXRoIG5vIGxvd2VyY2FzZSB2YXJpYW50cyBhbmQvb3IgdW5jYXNlZCBsZXR0ZXJzIGFyZSBzdGlsbCBhbGxvd2VkLlxuICAgKiBBcHBsaWNhdGlvbkNvbW1hbmRUeXBlcy5Vc2VyYCBhbmQgYEFwcGxpY2F0aW9uQ29tbWFuZFR5cGVzLk1lc3NhZ2VgIGNvbW1hbmRzIG1heSBiZSBtaXhlZCBjYXNlIGFuZCBjYW4gaW5jbHVkZSBzcGFjZXMuXG4gICAqL1xuICBuYW1lOiBzdHJpbmdcbiAgLyoqIExvY2FsaXphdGlvbiBvYmplY3QgZm9yIHRoZSBgbmFtZWAgZmllbGQuIFZhbHVlcyBmb2xsb3cgdGhlIHNhbWUgcmVzdHJpY3Rpb25zIGFzIGBuYW1lYCAqL1xuICBuYW1lTG9jYWxpemF0aW9ucz86IExvY2FsaXphdGlvblxuICAvKiogMS0xMDAgY2hhcmFjdGVyIGRlc2NyaXB0aW9uICovXG4gIGRlc2NyaXB0aW9uOiBzdHJpbmdcbiAgLyoqIExvY2FsaXphdGlvbiBvYmplY3QgZm9yIHRoZSBgZGVzY3JpcHRpb25gIGZpZWxkLiBWYWx1ZXMgZm9sbG93IHRoZSBzYW1lIHJlc3RyaWN0aW9ucyBhcyBgZGVzY3JpcHRpb25gICovXG4gIGRlc2NyaXB0aW9uTG9jYWxpemF0aW9ucz86IExvY2FsaXphdGlvblxuICAvKiogVHlwZSBvZiBjb21tYW5kLCBkZWZhdWx0cyBgQXBwbGljYXRpb25Db21tYW5kVHlwZXMuQ2hhdElucHV0YCBpZiBub3Qgc2V0ICAqL1xuICB0eXBlPzogQXBwbGljYXRpb25Db21tYW5kVHlwZXNcbiAgLyoqIFBhcmFtZXRlcnMgZm9yIHRoZSBjb21tYW5kICovXG4gIG9wdGlvbnM/OiBBcHBsaWNhdGlvbkNvbW1hbmRPcHRpb25bXVxuICAvKiogU2V0IG9mIHBlcm1pc3Npb25zIHJlcHJlc2VudGVkIGFzIGEgYml0IHNldCAqL1xuICBkZWZhdWx0TWVtYmVyUGVybWlzc2lvbnM/OiBQZXJtaXNzaW9uU3RyaW5nc1tdXG4gIC8qKiBJbmRpY2F0ZXMgd2hldGhlciB0aGUgY29tbWFuZCBpcyBhdmFpbGFibGUgaW4gRE1zIHdpdGggdGhlIGFwcCwgb25seSBmb3IgZ2xvYmFsbHktc2NvcGVkIGNvbW1hbmRzLiBCeSBkZWZhdWx0LCBjb21tYW5kcyBhcmUgdmlzaWJsZS4gKi9cbiAgZG1QZXJtaXNzaW9uPzogYm9vbGVhblxufVxuXG4vKiogaHR0cHM6Ly9kaXNjb3JkLmNvbS9kZXZlbG9wZXJzL2RvY3MvaW50ZXJhY3Rpb25zL2FwcGxpY2F0aW9uLWNvbW1hbmRzI2VuZHBvaW50cy1qc29uLXBhcmFtcyAqL1xuZXhwb3J0IGludGVyZmFjZSBDcmVhdGVDb250ZXh0QXBwbGljYXRpb25Db21tYW5kXG4gIGV4dGVuZHMgT21pdDxcbiAgQ3JlYXRlU2xhc2hBcHBsaWNhdGlvbkNvbW1hbmQsXG4gICdvcHRpb25zJyB8ICdkZXNjcmlwdGlvbicgfCAnZGVzY3JpcHRpb25Mb2NhbGl6YXRpb25zJ1xuICA+IHtcbiAgLyoqIFRoZSB0eXBlIG9mIHRoZSBjb21tYW5kICovXG4gIHR5cGU6IEFwcGxpY2F0aW9uQ29tbWFuZFR5cGVzLk1lc3NhZ2UgfCBBcHBsaWNhdGlvbkNvbW1hbmRUeXBlcy5Vc2VyXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0NvbnRleHRBcHBsaWNhdGlvbkNvbW1hbmQgKFxuICBjb21tYW5kOiBDcmVhdGVBcHBsaWNhdGlvbkNvbW1hbmRcbik6IGNvbW1hbmQgaXMgQ3JlYXRlQ29udGV4dEFwcGxpY2F0aW9uQ29tbWFuZCB7XG4gIHJldHVybiAoXG4gICAgY29tbWFuZC50eXBlID09PSBBcHBsaWNhdGlvbkNvbW1hbmRUeXBlcy5NZXNzYWdlIHx8XG4gICAgY29tbWFuZC50eXBlID09PSBBcHBsaWNhdGlvbkNvbW1hbmRUeXBlcy5Vc2VyXG4gIClcbn1cblxuLyoqIGh0dHBzOi8vZGlzY29yZC5jb20vZGV2ZWxvcGVycy9kb2NzL2ludGVyYWN0aW9ucy9zbGFzaC1jb21tYW5kcyNpbnRlcmFjdGlvbi1yZXNwb25zZS1pbnRlcmFjdGlvbmFwcGxpY2F0aW9uY29tbWFuZGNhbGxiYWNrZGF0YSAqL1xuZXhwb3J0IGludGVyZmFjZSBJbnRlcmFjdGlvbkNhbGxiYWNrRGF0YSB7XG4gIC8qKiBUaGUgbWVzc2FnZSBjb250ZW50cyAodXAgdG8gMjAwMCBjaGFyYWN0ZXJzKSAqL1xuICBjb250ZW50Pzogc3RyaW5nXG4gIC8qKiBUcnVlIGlmIHRoaXMgaXMgYSBUVFMgbWVzc2FnZSAqL1xuICB0dHM/OiBib29sZWFuXG4gIC8qKiBFbWJlZGRlZCBgcmljaGAgY29udGVudCAodXAgdG8gNjAwMCBjaGFyYWN0ZXJzKSAqL1xuICBlbWJlZHM/OiBFbWJlZFtdXG4gIC8qKiBBbGxvd2VkIG1lbnRpb25zIGZvciB0aGUgbWVzc2FnZSAqL1xuICBhbGxvd2VkTWVudGlvbnM/OiBBbGxvd2VkTWVudGlvbnNcbiAgLyoqIFRoZSBjb250ZW50cyBvZiB0aGUgZmlsZSBiZWluZyBzZW50ICovXG4gIGZpbGU/OiBGaWxlQ29udGVudCB8IEZpbGVDb250ZW50W11cbiAgLyoqIFRoZSBjdXN0b21JZCB5b3Ugd2FudCB0byB1c2UgZm9yIHRoaXMgbW9kYWwgcmVzcG9uc2UuICovXG4gIGN1c3RvbUlkPzogc3RyaW5nXG4gIC8qKiBUaGUgdGl0bGUgeW91IHdhbnQgdG8gdXNlIGZvciB0aGlzIG1vZGFsIHJlc3BvbnNlLiAqL1xuICB0aXRsZT86IHN0cmluZ1xuICAvKiogVGhlIGNvbXBvbmVudHMgeW91IHdvdWxkIGxpa2UgdG8gaGF2ZSBzZW50IGluIHRoaXMgbWVzc2FnZSAqL1xuICBjb21wb25lbnRzPzogTWVzc2FnZUNvbXBvbmVudHNcbiAgLyoqIE1lc3NhZ2UgZmxhZ3MgY29tYmluZWQgYXMgYSBiaXQgZmllbGQgKG9ubHkgU1VQUFJFU1NfRU1CRURTIGFuZCBFUEhFTUVSQUwgY2FuIGJlIHNldCkgKi9cbiAgZmxhZ3M/OiBudW1iZXJcbiAgLyoqIEF1dG9jb21wbGV0ZSBjaG9pY2VzIChtYXggb2YgMjUgY2hvaWNlcykgKi9cbiAgY2hvaWNlcz86IEFwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbkNob2ljZVtdXG59XG5cbi8qKiBodHRwczovL2Rpc2NvcmQuY29tL2RldmVsb3BlcnMvZG9jcy9pbnRlcmFjdGlvbnMvc2xhc2gtY29tbWFuZHMjaW50ZXJhY3Rpb24tcmVzcG9uc2UgKi9cbmV4cG9ydCBpbnRlcmZhY2UgSW50ZXJhY3Rpb25SZXNwb25zZSB7XG4gIC8qKiBUaGUgdHlwZSBvZiByZXNwb25zZSAqL1xuICB0eXBlOiBJbnRlcmFjdGlvblJlc3BvbnNlVHlwZXNcbiAgLyoqIEFuIG9wdGlvbmFsIHJlc3BvbnNlIG1lc3NhZ2UgKi9cbiAgZGF0YT86IEludGVyYWN0aW9uQ2FsbGJhY2tEYXRhXG59XG4iXSwibmFtZXMiOlsiQXBwbGljYXRpb25Db21tYW5kVHlwZXMiLCJpc0NvbnRleHRBcHBsaWNhdGlvbkNvbW1hbmQiLCJjb21tYW5kIiwidHlwZSIsIk1lc3NhZ2UiLCJVc2VyIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUVFQSwyQkFBQUEsQ0FBdUIsS0FNbEIsbUJBQW1CLEFBNkMxQixRQUFPLFNBQVNDLDRCQUNkQyxDQUFpQyxDQUNXLENBQzVDLE9BQ0VBLEVBQVFDLElBQUksR0FBS0gsRUFBd0JJLE9BQU8sRUFDaERGLEVBQVFDLElBQUksR0FBS0gsRUFBd0JLLElBQUksQUFFakQsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discordeno/rest",
-  "version": "18.0.0-next.1381838",
+  "version": "18.0.0-next.c271a85",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",