dimscord/restapi

Search:
Group by:
Source   Edit  

Interaction with the Discord API via rest api.

if you have an exception use getCurrentDiscordHttpError instead of getCurrentException

Procs

proc `%`(o: set[UserFlags]): JsonNode {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc addChannelMessagePin(api: RestApi; channel_id, message_id: string;
                          reason = ""): owned(Future[void]) {.
    ...deprecated: "Use pinMessage instead.", stackTrace: false,
    raises: [Exception], tags: [RootEffect, TimeEffect, ReadDirEffect,
                                ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Deprecated: Use pinMessage instead.
Add pinned message. (Deprecated: use pinMessage) Source   Edit   
proc addGuildMember(api: RestApi; guild_id, user_id, access_token: string;
                    nick = none string; roles = none seq[string];
                    mute, deaf = none bool; reason = ""): Future[
    tuple[member: Member, exists: bool]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Adds a guild member. If member is in the guild, then exists will be true. Source   Edit   
proc addGuildMemberRole(api: RestApi; guild_id, user_id, role_id: string;
                        reason = ""): owned(Future[void]) {....stackTrace: false,
    raises: [Exception], tags: [RootEffect, TimeEffect, ReadDirEffect,
                                ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Assigns a member's role. Source   Edit   
proc addMessageReaction(api: RestApi; channel_id, message_id, emoji: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Adds a message reaction to a Discord message.
  • emoji Example: '👀', '💩', likethis:123456789012345678
Source   Edit   
proc addThreadMember(api: RestApi; channel_id, user_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Adds a thread member. Source   Edit   
proc beginGuildPrune(api: RestApi; guild_id: string; days: range[1 .. 30] = 7;
                     include_roles: seq[string] = @[];
                     compute_prune_count = true; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Begins a guild prune. Source   Edit   
proc bulkDeleteMessages(api: RestApi; channel_id: string;
                        message_ids: seq[string] | seq[Message]; reason = ""): owned(
    Future[void]) {....stackTrace: false.}
Bulk deletes messages. Source   Edit   
proc bulkEditApplicationCommandPermissions(api: RestApi;
    application_id, guild_id: string;
    permissions: seq[GuildApplicationCommandPermissions]): Future[
    seq[GuildApplicationCommandPermissions]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Batch edits permissions for all commands in a guild You can only add up to 10 permission overwrites for a command. Source   Edit   
proc bulkGuildBan(api: RestApi; guild_id: string; user_ids: seq[string];
                  delete_message_seconds = 0; reason = ""): Future[
    tuple[banned_users, failed_users: seq[string]]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Creates a guild ban. Source   Edit   
proc bulkOverwriteApplicationCommands(api: RestApi; application_id: string;
                                      commands: seq[ApplicationCommand];
                                      guild_id = ""): Future[
    seq[ApplicationCommand]] {....stackTrace: false,
                               raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Overwrites existing commands slash command that were registered in guild or application. This means that only the commands you send in this request will be available globally or in a specific guild
  • guild_id is optional.
Source   Edit   
proc consumeEntitlement(api: RestApi; application_id, entitlement_id: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
For One-Time Purchase consumable SKUs, marks a given entitlement for the user as consumed. Source   Edit   
proc createApplicationEmoji(api: RestApi; application_id: string;
                            name, image: string): Future[Emoji] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Creates an application emoji. Source   Edit   
proc createAutoModerationRule(api: RestApi; guild_id, name: string;
                              event_type: int;
                              trigger_type: ModerationTriggerType;
                              trigger_metadata = none TriggerMetadata;
                              actions: seq[ModerationAction] = @[];
                              enabled = false; exempt_roles, exempt_channels: seq[
    string] = @[]; reason = ""): Future[AutoModerationRule] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
event_type is gonna be 1 for SEND_MESSAGE Source   Edit   
proc createChannelInvite(api: RestApi; channel_id: string; max_age = 86400;
                         max_uses = 0; temporary, unique = false;
                         target_user = none string;
                         target_user_id, target_application_id = none string;
                         target_type = none InviteTargetType; reason = ""): Future[
    Invite] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Creates an instant channel invite. Source   Edit   
proc createFollowupMessage(api: RestApi;
                           application_id, interaction_token: string;
                           content = ""; tts = false; files = newSeq();
                           attachments = newSeq(); embeds = newSeq();
                           allowed_mentions = none AllowedMentions;
                           components = newSeq(); flags: set[MessageFlags] = {};
                           thread_id, thread_name = none string;
                           applied_tags: seq[string] = @[];
                           poll = none PollRequest): Future[Message] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [ReadIOEffect,
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect],
    forbids: [].}
Create a followup message.
  • flags can set the followup message as ephemeral (which can be 64).
Source   Edit   
proc createGroupDm(api: RestApi; access_tokens: seq[string];
                   nicks: Table[string, string]): Future[DMChannel] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Creates a Group DM Channel.
  • nicks Example: {"2123450": "MrDude"}.toTable
Source   Edit   
proc createGuild(api: RestApi; name, region = none string;
                 icon, afk_channel_id, system_channel_id = none string;
                 verification_level, default_message_notifications = none int;
                 afk_timeout, explicit_content_filter = none int;
                 system_channel_flags = none int; roles = none seq[Role];
                 channels = none seq[objects.Channel]): Future[Guild] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Create a guild. Please read these notes: https://discord.com/developers/docs/resources/guild#create-guild Source   Edit   
proc createGuildBan(api: RestApi; guild_id, user_id: string;
                    deletemsgsecs: range[0 .. 604800] = 0; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Creates a guild ban. Source   Edit   
proc createGuildChannel(api: RestApi; guild_id, name: string; kind = 0;
                        parent_id, topic, rtc_region = none string;
                        nsfw = none bool;
                        position, video_quality_mode = none int;
                        default_sort_order, default_forum_layout = none int;
                        default_thread_rate_limit_per_user = none int;
                        available_tags = none seq[ForumTag];
                        default_reaction_emoji = none DefaultForumReaction;
                        rate_limit_per_user = none range[0 .. 21600];
                        bitrate = none range[8000 .. 128000];
                        user_limit = none range[0 .. 99];
                        permission_overwrites = none seq[Overwrite]; reason = ""): Future[
    GuildChannel] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Creates a channel. Source   Edit   
proc createGuildEmoji(api: RestApi; guild_id, name, image: string;
                      roles: seq[string] = @[]; reason = ""): Future[Emoji] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Creates a guild emoji. The image needs to be a base64 string. (See: https://nim-lang.org/docs/base64.html) Source   Edit   
proc createGuildFromTemplate(api: RestApi; code: string): Future[Guild] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Create a guild from a template, this endpoint is used for bots that are in >10 guilds Source   Edit   
proc createGuildRole(api: RestApi; guild_id: string; name = "new role";
                     unicode_emoji, icon = none string;
                     hoist, mentionable = false;
                     permissions: set[PermissionFlags] = {};
                     role_colors = none RoleColors; color = 0; reason = ""): Future[
    Role] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Creates a guild role. Source   Edit   
proc createGuildSticker(api: RestApi; guild_id: string;
                        name, tags, file: string; description, reason = ""): Future[
    Sticker] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Create a guild sticker. Max file size 512KB. Source   Edit   
proc createGuildTemplate(api: RestApi; guild_id, name: string;
                         description = none string): Future[GuildTemplate] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Create a guild template Source   Edit   
proc createInteractionResponse(api: RestApi;
                               interaction_id, interaction_token: string;
                               response: InteractionResponse): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [ReadIOEffect,
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect],
                    forbids: [].}

Creates a generic interaction response. Can be used for anything related to interaction responses. response.kind is required.

Look at:

Source   Edit   
proc createScheduledEvent(api: RestApi; guild_id: string;
                          name, scheduled_start_time: string; channel_id,
    scheduled_end_time, description = none string; image = none string;
                          privacy_level: GuildScheduledEventPrivacyLevel;
                          entity_type: EntityType;
                          entity_metadata = none EntityMetadata;
                          recurrence_rule = none RecurrenceRule; reason = ""): Future[
    GuildScheduledEvent] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Create a scheduled event in a guild. Source   Edit   
proc createSoundboardSound(api: RestApi; guild_id, name: string; sound: string;
                           volume: float = 1.0;
                           emoji_id, emoji_name = none string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}

Create soundboard sound.

Note that sound has to be base64 encoded.

Source   Edit   
proc createStageInstance(api: RestApi; channel_id, topic: string;
                         privacy_level = int plGuildOnly; reason = ""): Future[
    StageInstance] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Create a stage instance. Requires the current user to be a moderator of the stage channel. Source   Edit   
proc createTestEntitlement(api: RestApi; application_id: string;
                           sku_id, owner_id: string; owner_type: range[1 .. 2]): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Creates a test entitlement to a given SKU for a given guild or user. Discord will act as though that user or guild has entitlement to your premium offering.
  • owner_type - 1 for a guild subscription, 2 for a user subscription.
Source   Edit   
proc createUserDm(api: RestApi; user_id: string): Future[DMChannel] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Create user dm. Source   Edit   
proc createWebhook(api: RestApi; channel_id, name: string; avatar = none string;
                   reason = ""): Future[Webhook] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Creates a webhook. (webhook names cannot be: 'clyde', and they range 1-80) Source   Edit   
proc crosspostMessage(api: RestApi; channel_id, message_id: string): Future[
    Message] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Crosspost channel message aka publish messages into news channels. Source   Edit   
proc defaultSoundboardSounds(api: RestApi): Future[seq[SoundboardSound]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc deleteAllMessageReactions(api: RestApi; channel_id, message_id: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Remove all message reactions. Source   Edit   
proc deleteApplicationCommand(api: RestApi; application_id, command_id: string;
                              guild_id = ""): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Delete slash command for a specific application, guild_id is optional. Source   Edit   
proc deleteApplicationEmoji(api: RestApi; application_id: string): Future[Emoji] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Deletes an application emoji. Source   Edit   
proc deleteAutoModerationRule(api: RestApi; guild_id, rule_id: string;
                              reason = ""): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Source   Edit   
proc deleteChannel(api: RestApi; channel_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes or closes a channel. Source   Edit   
proc deleteChannelMessagePin(api: RestApi; channel_id, message_id: string;
                             reason = ""): owned(Future[void]) {.
    ...deprecated: "Use unpinMessage instead", stackTrace: false,
    raises: [Exception], tags: [RootEffect, TimeEffect, ReadDirEffect,
                                ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Deprecated: Use unpinMessage instead
Remove pinned message. (Deprecated: use unpinMessage) Source   Edit   
proc deleteEntitlement(api: RestApi; application_id, entitlement_id: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a currently-active test entitlement. Discord will act as though that user or guild no longer has entitlement to your premium offering. Source   Edit   
proc deleteGuild(api: RestApi; guild_id: string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Deletes a guild. Source   Edit   
proc deleteGuildChannelPermission(api: RestApi;
                                  channel_id, overwrite_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a guild channel overwrite.
  • overwrite_id -> Can be user id or role id.
Source   Edit   
proc deleteGuildEmoji(api: RestApi; guild_id, emoji_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a guild emoji. Source   Edit   
proc deleteGuildIntegration(api: RestApi; integ_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a guild integration. Source   Edit   
proc deleteGuildRole(api: RestApi; guild_id, role_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a guild role. Source   Edit   
proc deleteGuildSticker(api: RestApi; guild_id, sticker_id: string; reason = ""): Future[
    Sticker] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Deletes a guild sticker. Source   Edit   
proc deleteGuildTemplate(api: RestApi; guild_id, code: string): Future[
    GuildTemplate] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Delete guild template. Source   Edit   
proc deleteInteractionResponse(api: RestApi; application_id, interaction_token,
    message_id: string): owned(Future[void]) {....stackTrace: false,
    raises: [Exception], tags: [RootEffect, TimeEffect, ReadDirEffect,
                                ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Delete followup message or interaction response. Source   Edit   
proc deleteInvite(api: RestApi; code: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a guild invite. Source   Edit   
proc deleteMessage(api: RestApi; channel_id, message_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a discord message. Source   Edit   
proc deleteMessageReaction(api: RestApi; channel_id, message_id, emoji: string;
                           user_id = "@me"): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Deletes the user's or the bot's message reaction to a Discord message. Source   Edit   
proc deleteMessageReactionEmoji(api: RestApi;
                                channel_id, message_id, emoji: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes all the reactions for emoji. Source   Edit   
proc deleteScheduledEvent(api: RestApi; guild_id, event_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Delete a scheduled event in guild. Source   Edit   
proc deleteSoundboardSound(api: RestApi; guild_id, sound_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Source   Edit   
proc deleteStageInstance(api: RestApi; channel_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Delete the stage instance. Source   Edit   
proc deleteWebhook(api: RestApi; webhook_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Deletes a webhook. Source   Edit   
proc deleteWebhookMessage(api: RestApi;
                          webhook_id, webhook_token, message_id: string;
                          thread_id = none string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Delete webhook message. Source   Edit   
proc editApplicationCommand(api: RestApi; application_id, command_id: string;
                            guild_id, name, description = "";
    name_localizations, description_localizations = none Table[string, string];
    default_member_permissions = none set[PermissionFlags]; nsfw = false;
                            options: seq[ApplicationCommandOption] = @[];
                            contexts = none seq[InteractionContextType];
    integration_types = none seq[ApplicationIntegrationType]): Future[
    ApplicationCommand] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Modify slash command for a specific application.
  • guild_id - Optional
  • name - Optional Character length (3 - 32)
  • descripton - Optional Character length (1 - 100)
Source   Edit   
proc editApplicationEmoji(api: RestApi; application_id: string; name: string): Future[
    Emoji] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Edits an application emoji. Source   Edit   
proc editAutoModerationRule(api: RestApi; guild_id, rule_id: string;
                            event_type = none int; name = none string;
                            trigger_type = none ModerationTriggerType;
                            trigger_metadata = none TriggerMetadata;
                            actions = none seq[ModerationAction];
                            enabled = none bool;
                            exempt_roles, exempt_channels = none seq[string];
                            reason = ""): Future[AutoModerationRule] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
event_type is gonna be 1 for SEND_MESSAGE Source   Edit   
proc editCurrentApplication(api: RestApi; custom_install_url, description, icon = none
    string; role_connections_verification_url = none string;
                            install_params = none ApplicationInstallParams;
                            flags = none set[PermissionFlags]; cover_image,
    interactions_endpoint_url = none string; tags = none seq[string];
    integration_types_config = none Table[ApplicationIntegrationType,
    ApplicationIntegrationTypeConfig]): Future[Application] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Edits the current application for the current user (bot user). Source   Edit   
proc editCurrentMember(api: RestApi; guild_id: string; nick = none string;
                       reason = ""): owned(Future[void]) {....stackTrace: false,
    raises: [Exception], tags: [RootEffect, TimeEffect, ReadDirEffect,
                                ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Modify current member. nick - some "" to reset nick. Source   Edit   
proc editCurrentUser(api: RestApi; username, avatar = none string): Future[User] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Modifies the bot's username or avatar. Source   Edit   
proc editCurrentUserVoiceState(api: RestApi; guild_id, channel_id: string;
                               request_to_speak_timestamp = none string;
                               suppress = none bool; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Modify current user voice state Source   Edit   
proc editGuild(api: RestApi; guild_id: string;
               name, description, region, afk_channel_id, icon = none string;
               discovery_splash, owner_id, splash, banner = none string;
               system_channel_id, rules_channel_id = none string;
               safety_alerts_channel_id = none string;
               preferred_locale, public_updates_channel_id = none string;
               verification_level, default_message_notifications = none int;
               system_channel_flags = none int;
               explicit_content_filter, afk_timeout = none int;
               features = none seq[string];
               premium_progress_bar_enabled = none bool; reason = ""): Future[
    Guild] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Modifies a guild. Icon needs to be a base64 image. (See: https://nim-lang.org/docs/base64.html)

Read more at: https://discord.com/developers/docs/resources/guild#modify-guild

Source   Edit   
proc editGuildApplicationCommandPermissions(api: RestApi;
    application_id, guild_id, command_id: string;
    permissions: seq[ApplicationCommandPermission]): Future[
    GuildApplicationCommandPermissions] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Edits command permissions for a specific command for your application in a guild. You can only add up to 10 permission overwrites for a command Source   Edit   
proc editGuildChannel(api: RestApi; channel_id: string;
                      name, parent_id, topic, rtc_region = none string;
    default_auto_archive_duration, video_quality_mode = none int;
                      flags = none set[ChannelFlags];
                      available_tags = none seq[ForumTag];
                      default_reaction_emoji = none DefaultForumReaction;
                      default_sort_order, default_forum_layout = none int;
                      rate_limit_per_user = none range[0 .. 21600];
    default_thread_rate_limit_per_user = none range[0 .. 21600];
                      bitrate = none range[8000 .. 128000];
                      user_limit = none range[0 .. 99]; position = none int;
                      permission_overwrites = none seq[Overwrite];
                      nsfw = none bool; reason = ""): Future[GuildChannel] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Modify a guild channel. Source   Edit   
proc editGuildChannelPermissions(api: RestApi; channel_id, overwrite_id: string;
                                 kind: OverwriteType;
                                 allow, deny = none set[PermissionFlags];
                                 reason = ""): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Modify the channel's permissions. This is known as the channel's permission overwrite.
  • overwrite_id -> Can be user id or role id.
  • allow is the allowed permissions and deny is denied permissions.
Source   Edit   
proc editGuildChannelPositions(api: RestApi; guild_id, channel_id: string;
                               position = none int; parent_id = none string;
                               lock_permissions = false; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Edits a guild channel's position. Source   Edit   
proc editGuildEmoji(api: RestApi; guild_id, emoji_id: string;
                    name = none string; roles = none seq[string]; reason = ""): Future[
    Emoji] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Modifies a guild emoji. Source   Edit   
proc editGuildIncidentActions(api: RestApi; guild_id: string;
    invites_disabled_until, dms_disabled_until = none string; reason = ""): Future[
    IncidentsData] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc editGuildIntegration(api: RestApi; guild_id, integ_id: string;
                          expire_behavior, expire_grace_period = none int;
                          enable_emoticons = none bool; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Edits a guild integration. Source   Edit   
proc editGuildMember(api: RestApi; guild_id, user_id: string; nick, channel_id,
    communication_disabled_until = none string; roles = none seq[string];
                     mute, deaf = none bool; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Modifies a guild member Note:
  • communication_disabled_until - ISO8601 timestamp :: <=28 days
Source   Edit   
proc editGuildMFALevel(api: RestApi; guild_id: string; level: MFALevel;
                       reason = ""): Future[MFALevel] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Modify Guild MFA Level, requiring guild ownership. Source   Edit   
proc editGuildOnboarding(api: RestApi; guild_id: string;
                         prompts = none seq[GuildOnboardingPrompt];
                         default_channel_ids = none seq[string];
                         enabled = none bool; mode = none GuildOnboardingMode;
                         reason = ""): Future[GuildOnboarding] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Modify guild onboarding. Source   Edit   
proc editGuildRole(api: RestApi; guild_id, role_id: string; name = none string;
                   permissions = none set[PermissionFlags];
                   icon, unicode_emoji = none string; colors = none RoleColors;
                   color = none int; hoist, mentionable = none bool; reason = ""): Future[
    Role] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Modifies a guild role. Source   Edit   
proc editGuildRolePosition(api: RestApi; guild_id, role_id: string;
                           position = none int; reason = ""): Future[seq[Role]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Edits guild role position. Same as editGuildRolePositions but for one role. Source   Edit   
proc editGuildRolePositions(api: RestApi; guild_id: string; positions: seq[
    tuple[id: string, position: Option[int]]]; reason = ""): Future[seq[Role]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Edits guild role positions. Source   Edit   
proc editGuildSticker(api: RestApi; guild_id, sticker_id: string;
                      name, description, tags = none string; reason = ""): Future[
    Sticker] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Modify a guild sticker. Source   Edit   
proc editGuildTemplate(api: RestApi; guild_id, code: string;
                       name, description = none string): Future[GuildTemplate] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Modify a guild template. Source   Edit   
proc editGuildWelcomeScreen(api: RestApi; guild_id: string; enabled = none bool;
                            welcome_channels = none seq[WelcomeChannel];
                            description = none string; reason = ""): Future[
    tuple[description: Option[string], welcome_channels: seq[WelcomeChannel]]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc editGuildWidget(api: RestApi; guild_id: string; enabled = none bool;
                     channel_id = none string; reason = ""): Future[
    tuple[enabled: bool, channel_id: Option[string]]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Modifies a guild widget. Source   Edit   
proc editInteractionResponse(api: RestApi;
                             application_id, interaction_token: string;
                             message_id: string = "@original";
                             content = none string; embeds = newSeq();
                             flags: set[MessageFlags] = {};
                             allowed_mentions = none AllowedMentions;
                             attachments = newSeq(); files = newSeq();
                             components = newSeq()): Future[Message] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [ReadIOEffect,
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect],
    forbids: [].}
Modifies interaction response You can actually use this to modify original interaction or followup message.
  • message_id can be @original
Source   Edit   
proc editMessage(api: RestApi; channel_id, message_id: string; content = "";
                 tts = false; flags: set[MessageFlags] = {}; files = newSeq();
                 embeds = newSeq(); attachments = newSeq();
                 components = newSeq()): Future[Message] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [ReadIOEffect, RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect], forbids: [].}
Edits a discord message. Source   Edit   
proc editScheduledEvent(api: RestApi; guild_id, event_id: string;
                        name, scheduled_start_time, image = none string;
    channel_id, scheduled_end_time, description = none string;
                        privacy_level = none GuildScheduledEventPrivacyLevel;
                        entity_type = none EntityType;
                        entity_metadata = none EntityMetadata;
                        status = none GuildScheduledEventStatus;
                        recurrence_rule = none RecurrenceRule; reason = ""): Future[
    GuildScheduledEvent] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Update a scheduled event in a guild. Read more: https://discord.com/developers/docs/resources/guild-scheduled-event#modify-guild-scheduled-event-json-params Source   Edit   
proc editSoundboardSound(api: RestApi; guild_id, sound_id: string;
                         name = none string; volume = none float;
                         emoji_id, emoji_name = none string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Source   Edit   
proc editStageInstance(api: RestApi; channel_id, topic: string;
                       privacy_level = none int; reason = ""): Future[
    StageInstance] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Modify a stage instance. Requires the current user to be a moderator of the stage channel. Source   Edit   
proc editUserVoiceState(api: RestApi; guild_id, user_id: string;
                        channel_id, request_to_speak_timestamp = none string;
                        suppress = none bool; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Modify user or current user voice state, read more at: https://discord.com/developers/docs/resources/guild#update-current-user-voice-state or https://discord.com/developers/docs/resources/guild#update-user-voice-state-caveats
  • user_id You can set "@me", as the bot.
Source   Edit   
proc editWebhook(api: RestApi; webhook_id: string;
                 name, avatar, channel_id = none string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Modifies a webhook. Source   Edit   
proc editWebhookMessage(api: RestApi;
                        webhook_id, webhook_token, message_id: string;
                        content, thread_id = none string; embeds = newSeq();
                        allowed_mentions = none AllowedMentions;
                        attachments = newSeq(); flags: set[MessageFlags] = {};
                        files = newSeq(); components = newSeq()): Future[Message] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [ReadIOEffect,
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect],
    forbids: [].}
Modifies the webhook message. You can actually use this to modify original interaction or followup message.
  • webhook_id can also be application_id
  • webhook_token can also be interaction token.
  • message_id can be @original
Source   Edit   
proc endPoll(api: RestApi; channel_id, message_id: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Source   Edit   
proc executeGithubWebhook(api: RestApi; webhook_id, token: string; wait = true;
                          thread_id = none string): Future[Option[Message]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Executes a github webhook. Source   Edit   
proc executeSlackWebhook(api: RestApi; webhook_id, token: string; wait = true;
                         thread_id = none string): Future[Option[Message]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Executes a slack webhook. Source   Edit   
proc executeWebhook(api: RestApi; webhook_id, webhook_token: string;
                    wait = true; with_components = false;
                    thread_id, thread_name = none string; content = "";
                    tts = false; flags: set[MessageFlags] = {};
                    files = newSeq(); attachments = newSeq(); embeds = newSeq();
                    allowed_mentions = none AllowedMentions;
                    username, avatar_url = none string; components = newSeq();
                    applied_tags: seq[string] = @[]; poll = none PollRequest): Future[
    Option[Message]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    ReadIOEffect, RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect,
    WriteIOEffect], forbids: [].}
Executes a webhook or create a followup message.
  • webhook_id can be used as application id
  • webhook_token can be used as interaction token
  • flags are only used for interaction responses
Source   Edit   
proc followAnnouncementChannel(api: RestApi;
                               channel_id, webhook_channel_id: string;
                               reason = ""): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Follow announcement channel. Source   Edit   
proc getApplicationCommand(api: RestApi; application_id: string; guild_id = "";
                           command_id: string): Future[ApplicationCommand] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get slash command for a specific application, guild_id is optional. Source   Edit   
proc getApplicationCommands(api: RestApi; application_id: string; guild_id = "";
                            with_localizations = false): Future[
    seq[ApplicationCommand]] {....stackTrace: false,
                               raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Get slash commands for a specific application, guild_id is optional. Source   Edit   
proc getApplicationEmojis(api: RestApi; application_id: string): Future[
    seq[Emoji]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
lists emojis made by a bot user application, Source   Edit   
proc getApplicationRoleConnectionMetadataRecords(api: RestApi;
    application_id: string): Future[seq[ApplicationRoleConnectionMetadata]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc getAutoModerationRule(api: RestApi; guild_id, rule_id: string): Future[
    AutoModerationRule] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getAutoModerationRules(api: RestApi; guild_id: string): Future[
    seq[AutoModerationRule]] {....stackTrace: false,
                               raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getChannel(api: RestApi; channel_id: string): Future[
    (Option[GuildChannel], Option[DMChannel])] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}

Gets channel by ID.

Another thing to keep in mind is that it returns a tuple of each possible channel as an option.

Example:

  • channel Is the result tuple, returned after awaiting getChannel.
  • If you want to get guild channel, then do channel[0]
  • OR if you want DM channel then do channel[1]
Source   Edit   
proc getChannelInvites(api: RestApi; channel_id: string): Future[seq[Invite]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a list of a channel's invites. Source   Edit   
proc getChannelMessage(api: RestApi; channel_id, message_id: string): Future[
    Message] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Get a channel message. Source   Edit   
proc getChannelMessages(api: RestApi; channel_id: string;
                        around, before, after = ""; limit: range[1 .. 100] = 50): Future[
    seq[Message]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets channel messages. Source   Edit   
proc getChannelPins(api: RestApi; channel_id: string): Future[seq[Message]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get channel pins. Source   Edit   
proc getChannelWebhooks(api: RestApi; channel_id: string): Future[seq[Webhook]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a list of a channel's webhooks. Source   Edit   
proc getCurrentApplication(api: RestApi): Future[Application] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets the current application for the current user (bot user). Source   Edit   
proc getCurrentGuildMember(api: RestApi; guild_id: string): Future[Member] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get guild member as the current user aka you. Source   Edit   
proc getCurrentUser(api: RestApi): Future[User] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Gets the current user. Source   Edit   
proc getCurrentUserGuilds(api: RestApi; before, after = none string;
                          with_counts = false; limit: range[1 .. 200] = 200): Future[
    seq[Guild]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets current user guilds. Source   Edit   
proc getEntitlements(api: RestApi; application_id: string;
                     user_id, before, after, guild_id = none string;
                     sku_ids = none seq[string]; limit: range[1 .. 100] = 100;
                     exclude_ended = false): Future[seq[Entitlement]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Returns all entitlements for a given app, active and expired. Source   Edit   
proc getGateway(api: RestApi): Future[string] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Get Discord gateway URL. Source   Edit   
proc getGatewayBot(api: RestApi): Future[GatewayBot] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Get gateway bot with authentication. Source   Edit   
proc getGuild(api: RestApi; guild_id: string; with_counts = false): Future[Guild] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a guild. Source   Edit   
proc getGuildApplicationCommandPermissions(api: RestApi;
    application_id, guild_id: string): Future[
    seq[GuildApplicationCommandPermissions]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Fetches command permissions for all commands for your application in a guild Source   Edit   
proc getGuildApplicationCommandPermissions(api: RestApi;
    application_id, guild_id, command_id: string): Future[
    GuildApplicationCommandPermissions] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Fetches command permissions for a specific command for your application in a guild Source   Edit   
proc getGuildAuditLogs(api: RestApi; guild_id: string; user_id, before = "";
                       action_type = -1; limit: range[1 .. 100] = 50): Future[
    AuditLog] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Get guild audit logs. The maximum limit is 100. Source   Edit   
proc getGuildBan(api: RestApi; guild_id, user_id: string): Future[GuildBan] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets guild ban. Source   Edit   
proc getGuildBans(api: RestApi; guild_id: string): Future[seq[GuildBan]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets all the guild bans. Source   Edit   
proc getGuildChannels(api: RestApi; guild_id: string): Future[seq[GuildChannel]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a list of a guild's channels Source   Edit   
proc getGuildEmoji(api: RestApi; guild_id: string; emoji_id: string): Future[
    Emoji] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getGuildEmojis(api: RestApi; guild_id: string): Future[seq[Emoji]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc getGuildIntegrations(api: RestApi; guild_id: string): Future[
    seq[Integration]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets a list of guild integrations. Source   Edit   
proc getGuildInvites(api: RestApi; guild_id: string): Future[seq[InviteMetadata]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets guild invites. Source   Edit   
proc getGuildMember(api: RestApi; guild_id, user_id: string): Future[Member] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a guild member. Source   Edit   
proc getGuildMembers(api: RestApi; guild_id: string;
                     limit: range[1 .. 1000] = 1; after = "0"): Future[
    seq[Member]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets a list of a guild's members. Source   Edit   
proc getGuildOnboarding(api: RestApi; guild_id: string): Future[GuildOnboarding] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets guild onboarding. Source   Edit   
proc getGuildPreview(api: RestApi; guild_id: string): Future[GuildPreview] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets guild preview. Source   Edit   
proc getGuildPruneCount(api: RestApi; guild_id: string;
                        days: range[1 .. 30] = 7;
                        include_roles: seq[string] = @[]): Future[int] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets the prune count. Source   Edit   
proc getGuildRoles(api: RestApi; guild_id: string): Future[seq[Role]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets the guild's roles. Source   Edit   
proc getGuildSoundboard(api: RestApi; guild_id: string): Future[
    seq[SoundboardSound]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getGuildSticker(api: RestApi; guild_id, sticker_id: string): Future[Sticker] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a guild sticker. Source   Edit   
proc getGuildStickers(api: RestApi; guild_id: string): Future[seq[Sticker]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
List guild stickers. Source   Edit   
proc getGuildTemplate(api: RestApi; code: string): Future[GuildTemplate] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get guild template from its code. Source   Edit   
proc getGuildVanityUrl(api: RestApi; guild_id: string): Future[
    tuple[code: Option[string], uses: int]] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Gets the guild vanity url. Source   Edit   
proc getGuildVoiceRegions(api: RestApi; guild_id: string): Future[
    seq[VoiceRegion]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets a guild's voice regions. Source   Edit   
proc getGuildWebhooks(api: RestApi; guild_id: string): Future[seq[Webhook]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a list of a channel's webhooks. Source   Edit   
proc getGuildWelcomeScreen(api: RestApi; guild_id: string): Future[
    tuple[description: Option[string], welcome_channels: seq[WelcomeChannel]]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc getGuildWidget(api: RestApi; guild_id: string): Future[GuildWidgetJson] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a guild widget. Source   Edit   
proc getInteractionResponse(api: RestApi; application_id, interaction_token,
    message_id: string): Future[Message] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Get interaction response or follow up message. Source   Edit   
proc getInvite(api: RestApi; code: string; with_counts, with_expiration = false;
               auth = false; guild_scheduled_event_id = none string): Future[
    Invite] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets a discord invite, it can be a vanity code.
  • auth Whether you should get the invite while authenticated.
Source   Edit   
proc getMessageReactions(api: RestApi; channel_id, message_id, emoji: string;
                         kind = ReactionType.rtNormal; after = "";
                         limit: range[1 .. 100] = 25): Future[seq[User]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get all user message reactions on the emoji provided. Source   Edit   
proc getNitroStickerPacks(api: RestApi): Future[seq[StickerPack]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc getPollAnswerVoters(api: RestApi;
                         channel_id, message_id, answer_id: string;
                         after = none string; limit: range[1 .. 100] = 25): Future[
    seq[User]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getScheduledEvent(api: RestApi; guild_id, event_id: string;
                       with_user_count = false): Future[GuildScheduledEvent] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get a scheduled event in a guild. Source   Edit   
proc getScheduledEvents(api: RestApi; guild_id: string): Future[
    seq[GuildScheduledEvent]] {....stackTrace: false,
                                raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Get all scheduled events in a guild. Source   Edit   
proc getScheduledEventUsers(api: RestApi; guild_id, event_id: string;
                            limit = 100; with_member = false; before, after = ""): Future[
    seq[GuildScheduledEventUser]] {....stackTrace: false,
                                    raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Gets the users that were subscribed to the scheduled events in the guild. Source   Edit   
proc getSkuSubscription(api: RestApi; sku_id, subscription_id: string): Future[
    Subscription] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Lists out SKUs for a given application. Source   Edit   
proc getStageInstance(api: RestApi; channel_id: string): Future[StageInstance] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get a stage instance. Source   Edit   
proc getSticker(api: RestApi; sticker_id: string): Future[Sticker] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc getThreadMember(api: RestApi; channel_id, user_id: string;
                     with_member = true): Future[ThreadMember] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get a thread member. Source   Edit   
proc getThreadMembers(api: RestApi; channel_id: string; with_member = true): Future[
    seq[ThreadMember]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
List thread members. Note: This endpoint requires the GUILD_MEMBERS Privileged Intent if not enabled on your application. Source   Edit   
proc getUser(api: RestApi; user_id: string): Future[User] {....stackTrace: false,
    raises: [Exception, ValueError], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Gets a user. Source   Edit   
proc getUserApplicationRoleConnection(api: RestApi; application_id: string): Future[
    ApplicationRoleConnection] {....stackTrace: false,
                                 raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Source   Edit   
proc getVoiceRegions(api: RestApi): Future[seq[VoiceRegion]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get voice regions Source   Edit   
proc getWebhook(api: RestApi; webhook_id: string): Future[Webhook] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Gets a webhook. Source   Edit   
proc getWebhookMessage(api: RestApi;
                       webhook_id, webhook_token, message_id: string;
                       thread_id = none string): Future[Message] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Get webhook message. Source   Edit   
proc interactionResponseAutocomplete(api: RestApi;
                                     interaction_id, interaction_token: string;
    response: InteractionCallbackDataAutocomplete): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Create an interaction response which is an autocomplete response. Source   Edit   
proc interactionResponseMessage(api: RestApi;
                                interaction_id, interaction_token: string;
                                kind: InteractionResponseType;
                                response: InteractionCallbackDataMessage): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [ReadIOEffect,
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, WriteIOEffect],
                    forbids: [].}
Create an interaction response.
  • response.kind is required.

Example:

await discord.api.interactionResponseMessage(
     interaction_id, interaction_token,
        kind = ..., # you can choose whichever
        response = InteractionCallbackDataMessage(
            flags: {mfIsEphemeral, mfIsComponentsV2},
            content: "What's up bro".
            components: @[...],
            ...
       )
)
)

Source   Edit   
proc interactionResponseModal(api: RestApi;
                              interaction_id, interaction_token: string;
                              response: InteractionCallbackDataModal): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Create an interaction response which is a modal. Source   Edit   
proc joinThread(api: RestApi; channel_id: string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Join thread. Source   Edit   
proc kickUserFromVoice(api: RestApi; guild_id, user_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Disconnect member from voice. Source   Edit   
proc leaveGuild(api: RestApi; guild_id: string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Leaves a guild. Source   Edit   
proc leaveThread(api: RestApi; channel_id: string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Leave thread. Source   Edit   
proc listActiveGuildThreads(api: RestApi; channel_id: string): Future[
    tuple[threads: seq[GuildChannel], members: seq[ThreadMember]]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Returns all active threads in the guild. Source   Edit   
proc listArchivedThreads(api: RestApi; joined: bool; typ, channel_id: string;
                         before = none string; limit = none int): Future[tuple[
    threads: seq[GuildChannel], members: seq[ThreadMember], has_more: bool]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
List public or private archived threads, either joined or not.
  • typ "public" or "private"
  • joined list joined private or public archived threads
Source   Edit   
proc listSKUs(api: RestApi; application_id: string): Future[seq[Sku]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Lists out SKUs for a given application. Source   Edit   
proc listSkuSubscriptions(api: RestApi; sku_id: string;
                          before, after, user_id = none(string); limit = 50): Future[
    seq[Subscription]] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Lists out SKUs for a given application. Source   Edit   
proc pinMessage(api: RestApi; channel_id, message_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Add pinned message. Source   Edit   
proc registerApplicationCommand(api: RestApi; application_id: string;
                                name: string; description, guild_id = "";
    name_localizations, description_localizations = none Table[string, string];
                                kind = atSlash; nsfw = false;
    default_member_permissions = none set[PermissionFlags];
                                options: seq[ApplicationCommandOption] = @[];
    integration_types = none seq[ApplicationIntegrationType];
                                contexts = none seq[InteractionContextType]): Future[
    ApplicationCommand] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Create a global or guild only slash command.
  • guild_id - Optional
  • name - Character length (3 - 32)
  • descripton - Character length (1 - 100)

NOTE: Creating a command with the same name as an existing command for your application will overwrite the old command.

Source   Edit   
proc removeGuildBan(api: RestApi; guild_id, user_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Removes a guild ban. Source   Edit   
proc removeGuildMember(api: RestApi; guild_id, user_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Removes a guild member. Source   Edit   
proc removeGuildMemberRole(api: RestApi; guild_id, user_id, role_id: string;
                           reason = ""): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Removes a member's role. Source   Edit   
proc removeThreadMember(api: RestApi; channel_id, user_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Remove thread member. Source   Edit   
proc searchGuildMembers(api: RestApi; guild_id, query: string;
                        limit: range[1 .. 1000] = 1): Future[seq[Member]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Search for guild members. Source   Edit   
proc sendMessage(api: RestApi; channel_id: string; content = ""; tts = false;
                 nonce: Option[string] or Option[int] = none(int);
                 flags: set[MessageFlags] = {}; files = newSeq[DiscordFile]();
                 embeds = newSeq[Embed](); attachments = newSeq[Attachment]();
                 allowed_mentions = none AllowedMentions;
                 message_reference = none MessageReference;
                 components = newSeq[MessageComponent]();
                 sticker_ids = newSeq[string](); poll = none PollRequest;
                 enforce_nonce = none bool): Future[Message] {....stackTrace: false.}
Sends a Discord message.
  • nonce This can be used for optimistic message sending
Source   Edit   
proc sendSoundboardSound(api: RestApi; channel_id, sound_id: string;
                         source_guild_id = none(string)): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Sends soundboard sound when joined in voice channel. Source   Edit   
proc setGuildNick(api: RestApi; guild_id: string; nick, reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Sets the current user's guild nickname, defaults to "" if no nick is set. Source   Edit   
proc startThreadWithMessage(api: RestApi; channel_id, message_id, name: string;
                            auto_archive_duration: range[60 .. 10080];
                            reason = ""): Future[GuildChannel] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Starts a public thread.
  • auto_archive_duration Duration in mins. Can set to: 60 1440 4320 10080
Source   Edit   
proc startThreadWithoutMessage(api: RestApi; channel_id, name: string;
                               auto_archive_duration: range[60 .. 10080];
                               kind = none ChannelType; invitable = none bool;
                               reason = ""): Future[GuildChannel] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Starts private thread.
  • auto_archive_duration Duration in mins. Can set to: 60 1440 4320 10080
Source   Edit   
proc startTyping(api: RestApi; channel_id: string): owned(Future[void]) {.
    ...stackTrace: false, raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Starts typing in a specific Discord channel. Source   Edit   
proc syncGuildIntegration(api: RestApi; guild_id, integ_id: string): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Syncs a guild integration. Source   Edit   
proc syncGuildTemplate(api: RestApi; guild_id, code: string): Future[
    GuildTemplate] {....stackTrace: false, raises: [Exception, ValueError], tags: [
    RootEffect, TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}
Sync guild template. Source   Edit   
proc triggerTypingIndicator(api: RestApi; channel_id: string): owned(
    Future[void]) {....deprecated: "Use startTyping instead", stackTrace: false,
                    raises: [Exception], tags: [RootEffect, TimeEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect], forbids: [].}
Deprecated: Use startTyping instead
Starts typing in a specific Discord channel. Deprecated: use startTyping instead. Source   Edit   
proc unpinMessage(api: RestApi; channel_id, message_id: string; reason = ""): owned(
    Future[void]) {....stackTrace: false, raises: [Exception], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
                    forbids: [].}
Remove pinned message. Source   Edit   
proc updateApplicationRoleConnectionMetadataRecords(api: RestApi;
    application_id: string): Future[seq[ApplicationRoleConnectionMetadata]] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit   
proc updateUserApplicationRoleConnection(api: RestApi; application_id: string;
    platform_name, platform_username = none string;
    metadata = none Table[string, string]): Future[ApplicationRoleConnection] {.
    ...stackTrace: false, raises: [Exception, ValueError], tags: [RootEffect,
    TimeEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}
Source   Edit  

Made with Nim. Generated: 2025-09-08 23:14:05 UTC