On This Page

REST Routes

1 symbol from @neontechspace/fluxerly

Interfaces#

RestRoutes#

Every Fluxer API route that client.rest.call checks at compile time, keyed by its method and path template as Fluxer's documentation writes them, such as POST /channels/{channel_id}/messages

Generated from Fluxer's API description at commit f50792ae705c of fluxerapp/fluxer, the commit the SDK release pins, with Fluxer's official field names and a few reviewed corrections where the description is wrong or incomplete. Each input lists the route's path parameters, query and JSON body. Each response is the parsed JSON body of a successful answer, which the SDK does not check at runtime. Routes Fluxer adds after the pin, and fields the description leaves out, need client.rest.request

interface RestRoutes
DELETE /channels/{channel_id}#

Delete a channel

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          {
              readonly delete_messages?: boolean
              readonly silent?: boolean
          }
      >
    & OptionalJsonBody<SudoVerificationSchema>,
    undefined
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly delete_messages?:
          boolean
        readonly silent?: boolean
      }
    >
  & OptionalJsonBody<
      SudoVerificationSchema
    >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}#

Delete a message

Route<PathParameters<ChannelIdMessageIdPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}/attachments/{attachment_id}#

Delete a message attachment

Route<PathParameters<ChannelIdMessageIdAttachmentIdPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdAttachmentIdPath
  >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}/reactions#

Remove all reactions from message

Route<PathParameters<ChannelIdMessageIdPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}/reactions/{emoji}#

Remove all reactions with emoji

Route<PathParameters<ChannelIdMessageIdEmojiPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdEmojiPath
  >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}/reactions/{emoji}/{target_id}#

Remove reaction from message

Route<
    & PathParameters<ChannelIdMessageIdEmojiTargetIdPath>
    & QueryParameters<{ readonly session_id?: string }>,
    undefined
>Route<
  & PathParameters<
      ChannelIdMessageIdEmojiTargetIdPath
    >
  & QueryParameters<
      { readonly session_id?: string }
    >,
  undefined
>
DELETE /channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me#

Remove own reaction from message

Route<
    & PathParameters<ChannelIdMessageIdEmojiPath>
    & QueryParameters<{ readonly session_id?: string }>,
    undefined
>Route<
  & PathParameters<
      ChannelIdMessageIdEmojiPath
    >
  & QueryParameters<
      { readonly session_id?: string }
    >,
  undefined
>
DELETE /channels/{channel_id}/messages/ack#

Deprecated. Fluxer's API description marks this route as deprecated

Clear channel read state

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
DELETE /channels/{channel_id}/permissions/{overwrite_id}#

Delete permission overwrite

Route<PathParameters<ChannelIdOverwriteIdPath>, undefined>Route<
  PathParameters<
    ChannelIdOverwriteIdPath
  >,
  undefined
>
DELETE /channels/{channel_id}/pins/{message_id}#

Unpin a message

Route<PathParameters<ChannelIdMessageIdPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  undefined
>
DELETE /channels/{channel_id}/recipients/{user_id}#

Remove recipient from group DM

Route<
    & PathParameters<ChannelIdUserIdPath>
    & QueryParameters<
          {
              readonly delete_messages?: boolean
              readonly silent?: boolean
          }
      >
    & OptionalJsonBody<SudoVerificationSchema>,
    undefined
>Route<
  & PathParameters<
      ChannelIdUserIdPath
    >
  & QueryParameters<
      {
        readonly delete_messages?:
          boolean
        readonly silent?: boolean
      }
    >
  & OptionalJsonBody<
      SudoVerificationSchema
    >,
  undefined
>
DELETE /channels/{channel_id}/tags/{tag_id}#

Delete a forum tag

Route<PathParameters<ChannelIdTagIdPath>, ChannelResponse>Route<
  PathParameters<ChannelIdTagIdPath>,
  ChannelResponse
>
DELETE /channels/{channel_id}/thread-members/{user_id}#

Remove a thread member

Route<PathParameters<ChannelIdUserIdPath>, undefined>Route<
  PathParameters<ChannelIdUserIdPath>,
  undefined
>
DELETE /channels/{channel_id}/thread-members/@me#

Leave a thread

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/bans/{user_id}#
Route<PathParameters<GuildIdUserIdPath>, undefined>Route<
  PathParameters<GuildIdUserIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/discovery#

Withdraw discovery application

Route<PathParameters<GuildIdPath>, undefined>Route<
  PathParameters<GuildIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/emojis/{emoji_id}#

Delete guild emoji

Route<
    & PathParameters<GuildIdEmojiIdPath>
    & QueryParameters<{ readonly purge?: boolean }>,
    undefined
>Route<
  & PathParameters<GuildIdEmojiIdPath>
  & QueryParameters<
      { readonly purge?: boolean }
    >,
  undefined
>
DELETE /guilds/{guild_id}/members/{user_id}#

Remove guild member

Route<PathParameters<GuildIdUserIdPath>, undefined>Route<
  PathParameters<GuildIdUserIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/members/{user_id}/roles/{role_id}#

Remove role from guild member

Route<PathParameters<GuildIdUserIdRoleIdPath>, undefined>Route<
  PathParameters<
    GuildIdUserIdRoleIdPath
  >,
  undefined
>
DELETE /guilds/{guild_id}/roles/{role_id}#

Delete guild role

Route<PathParameters<GuildIdRoleIdPath>, undefined>Route<
  PathParameters<GuildIdRoleIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/roles/hoist-positions#

Reset role hoist positions

Route<PathParameters<GuildIdPath>, undefined>Route<
  PathParameters<GuildIdPath>,
  undefined
>
DELETE /guilds/{guild_id}/stickers/{sticker_id}#

Delete guild sticker

Route<
    & PathParameters<GuildIdStickerIdPath>
    & QueryParameters<{ readonly purge?: boolean }>,
    undefined
>Route<
  & PathParameters<
      GuildIdStickerIdPath
    >
  & QueryParameters<
      { readonly purge?: boolean }
    >,
  undefined
>
DELETE /invites/{invite_code}#

Delete invite

Route<PathParameters<InviteCodePath>, undefined>Route<
  PathParameters<InviteCodePath>,
  undefined
>
DELETE /users/@me/channels/{channel_id}/pin#

Unpin direct message channel

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
DELETE /users/@me/guilds/{guild_id}#

Leave guild

Route<
    & PathParameters<GuildIdPath>
    & QueryParameters<{ readonly delete_messages?: boolean }>
    & OptionalJsonBody<SudoVerificationSchema>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & QueryParameters<
      {
        readonly delete_messages?:
          boolean
      }
    >
  & OptionalJsonBody<
      SudoVerificationSchema
    >,
  undefined
>
DELETE /webhooks/{webhook_id}#

Delete webhook

Route<PathParameters<WebhookIdPath>, undefined>Route<
  PathParameters<WebhookIdPath>,
  undefined
>
GET /applications/@me#

Get current bot application

Route<{ … }, ApplicationsMeResponse>
GET /channels/{channel_id}#

Fetch a channel

Route<PathParameters<ChannelIdPath>, ChannelResponse>Route<
  PathParameters<ChannelIdPath>,
  ChannelResponse
>
GET /channels/{channel_id}/follower-stats#

Get announcement channel follower stats

Route<PathParameters<ChannelIdPath>, ChannelFollowerStatsResponse>Route<
  PathParameters<ChannelIdPath>,
  ChannelFollowerStatsResponse
>
GET /channels/{channel_id}/invites#

List channel invites

Route<PathParameters<ChannelIdPath>, InviteMetadataListResponse>Route<
  PathParameters<ChannelIdPath>,
  InviteMetadataListResponse
>
GET /channels/{channel_id}/messages#

List messages in a channel

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          {
              readonly after?: SnowflakeType
              readonly around?: SnowflakeType
              readonly before?: SnowflakeType
              readonly limit?: number
          }
      >,
    MessageListResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly after?: SnowflakeType
        readonly around?:
          SnowflakeType
        readonly before?:
          SnowflakeType
        readonly limit?: number
      }
    >,
  MessageListResponse
>
GET /channels/{channel_id}/messages/{message_id}#

Fetch a message

Route<PathParameters<ChannelIdMessageIdPath>, MessageResponseSchema>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  MessageResponseSchema
>
GET /channels/{channel_id}/messages/{message_id}/crosspost-source#

Get the source community of a published message copy

Route<
    PathParameters<ChannelIdMessageIdPath>,
    CrosspostSourceResponse
>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  CrosspostSourceResponse
>
GET /channels/{channel_id}/messages/{message_id}/reactions/{emoji}#

List users who reacted with emoji

Route<
    & PathParameters<ChannelIdMessageIdEmojiPath>
    & QueryParameters<
          {
              readonly after?: SnowflakeType
              readonly limit?: number
          }
      >,
    ReactionUsersListResponse
>Route<
  & PathParameters<
      ChannelIdMessageIdEmojiPath
    >
  & QueryParameters<
      {
        readonly after?: SnowflakeType
        readonly limit?: number
      }
    >,
  ReactionUsersListResponse
>
GET /channels/{channel_id}/messages/{message_id}/reactions/{emoji}/users#

List users who reacted with emoji

Route<
    & PathParameters<ChannelIdMessageIdEmojiPath>
    & QueryParameters<
          {
              readonly after?: SnowflakeType
              readonly limit?: number
          }
      >,
    ReactionUsersPageResponse
>Route<
  & PathParameters<
      ChannelIdMessageIdEmojiPath
    >
  & QueryParameters<
      {
        readonly after?: SnowflakeType
        readonly limit?: number
      }
    >,
  ReactionUsersPageResponse
>
GET /channels/{channel_id}/messages/pins#

List pinned messages

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          { readonly before?: string; readonly limit?: number }
      >,
    ChannelPinsResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly before?: string
        readonly limit?: number
      }
    >,
  ChannelPinsResponse
>
GET /channels/{channel_id}/slowmode#

Fetch slowmode state

Route<PathParameters<ChannelIdPath>, ChannelSlowmodeStateResponse>Route<
  PathParameters<ChannelIdPath>,
  ChannelSlowmodeStateResponse
>
GET /channels/{channel_id}/thread-members#

List thread members

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          {
              readonly after?: SnowflakeType
              readonly limit?: number
              readonly with_member?: boolean
          }
      >,
    ThreadMemberListResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly after?: SnowflakeType
        readonly limit?: number
        readonly with_member?: boolean
      }
    >,
  ThreadMemberListResponse
>
GET /channels/{channel_id}/thread-members/{user_id}#

Get a thread member

Route<
    & PathParameters<ChannelIdUserIdPath>
    & QueryParameters<{ readonly with_member?: boolean }>,
    ThreadMemberResponse
>Route<
  & PathParameters<
      ChannelIdUserIdPath
    >
  & QueryParameters<
      {
        readonly with_member?: boolean
      }
    >,
  ThreadMemberResponse
>
GET /channels/{channel_id}/threads/archived/private#

List private archived threads

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          { readonly before?: string; readonly limit?: number }
      >,
    ArchivedThreadsResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly before?: string
        readonly limit?: number
      }
    >,
  ArchivedThreadsResponse
>
GET /channels/{channel_id}/threads/archived/public#

List public archived threads

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          { readonly before?: string; readonly limit?: number }
      >,
    ArchivedThreadsResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly before?: string
        readonly limit?: number
      }
    >,
  ArchivedThreadsResponse
>
GET /channels/{channel_id}/threads/search#

Search threads

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          {
              readonly archived?: boolean
              readonly limit?: number
              readonly max_id?: SnowflakeType
              readonly min_id?: SnowflakeType
              readonly name?: string
              readonly offset?: number
              readonly slop?: number
              readonly sort_by?: ThreadSearchSortBySchema
              readonly sort_order?: ThreadSearchSortOrderSchema
              readonly tag?: readonly SnowflakeType[]
              readonly tag_setting?: ForumTagSettingSchema
          }
      >,
    ThreadSearchResult
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly archived?: boolean
        readonly limit?: number
        readonly max_id?:
          SnowflakeType
        readonly min_id?:
          SnowflakeType
        readonly name?: string
        readonly offset?: number
        readonly slop?: number
        readonly sort_by?:
          ThreadSearchSortBySchema
        readonly sort_order?:
          ThreadSearchSortOrderSchema
        readonly tag?:
          readonly SnowflakeType[]
        readonly tag_setting?:
          ForumTagSettingSchema
      }
    >,
  ThreadSearchResult
>
GET /channels/{channel_id}/users/@me/threads/archived/private#

List joined private archived threads

Route<
    & PathParameters<ChannelIdPath>
    & QueryParameters<
          {
              readonly before?: SnowflakeType
              readonly limit?: number
          }
      >,
    ArchivedThreadsResponse
>Route<
  & PathParameters<ChannelIdPath>
  & QueryParameters<
      {
        readonly before?:
          SnowflakeType
        readonly limit?: number
      }
    >,
  ArchivedThreadsResponse
>
GET /channels/{channel_id}/webhooks#
Route<PathParameters<ChannelIdPath>, WebhookListResponse>Route<
  PathParameters<ChannelIdPath>,
  WebhookListResponse
>
GET /discovery/categories#

List discovery categories

Route<{ … }, DiscoveryCategoryListResponse>Route<
  { … },
  DiscoveryCategoryListResponse
>
GET /discovery/guilds#

Search discoverable guilds

Route<
    QueryParameters<
        {
            readonly category?: number
            readonly language?: string
            readonly limit?: number
            readonly offset?: number
            readonly query?: string
            readonly sort_by?:
                | "member_count" | "relevance" | "online_count"
            readonly tag?: string
        }
    >,
    DiscoveryGuildListResponse
>Route<
  QueryParameters<
    {
      readonly category?: number
      readonly language?: string
      readonly limit?: number
      readonly offset?: number
      readonly query?: string
      readonly sort_by?:
        | "member_count" | "relevance"
        | "online_count"
      readonly tag?: string
    }
  >,
  DiscoveryGuildListResponse
>
GET /emojis/{emoji_id}/metadata#

Get emoji metadata

Route<PathParameters<EmojiIdPath>, GuildEmojiMetadataResponse>Route<
  PathParameters<EmojiIdPath>,
  GuildEmojiMetadataResponse
>
GET /emojis/{emoji_id}/source#

Get emoji source guild

Route<
    PathParameters<EmojiIdPath>,
    GuildExpressionSourceGuildResponse
>Route<
  PathParameters<EmojiIdPath>,
  GuildExpressionSourceGuildResponse
>
GET /experiments#

Get the experiment assignments

Route<{ … }, ExperimentAssignmentsResponse>Route<
  { … },
  ExperimentAssignmentsResponse
>
GET /gateway/bot#

Get gateway information

Route<{ … }, GatewayBotResponse>
GET /guilds/{guild_id}#

Get guild information

Route<PathParameters<GuildIdPath>, GuildResponse>Route<
  PathParameters<GuildIdPath>,
  GuildResponse
>
GET /guilds/{guild_id}/audit-logs#

List guild audit logs

Route<
    & PathParameters<GuildIdPath>
    & QueryParameters<
          {
              readonly action_type?: AuditLogActionTypeInput
              readonly after?: SnowflakeType
              readonly before?: SnowflakeType
              readonly limit?: number
              readonly user_id?: SnowflakeType
          }
      >,
    GuildAuditLogListResponse
>Route<
  & PathParameters<GuildIdPath>
  & QueryParameters<
      {
        readonly action_type?:
          AuditLogActionTypeInput
        readonly after?: SnowflakeType
        readonly before?:
          SnowflakeType
        readonly limit?: number
        readonly user_id?:
          SnowflakeType
      }
    >,
  GuildAuditLogListResponse
>
GET /guilds/{guild_id}/bans#

List guild bans

Route<PathParameters<GuildIdPath>, GuildBanListResponse>Route<
  PathParameters<GuildIdPath>,
  GuildBanListResponse
>
GET /guilds/{guild_id}/channels#
Route<PathParameters<GuildIdPath>, ChannelListResponse>Route<
  PathParameters<GuildIdPath>,
  ChannelListResponse
>
GET /guilds/{guild_id}/discovery#

Get discovery status

Route<PathParameters<GuildIdPath>, DiscoveryStatusResponse>Route<
  PathParameters<GuildIdPath>,
  DiscoveryStatusResponse
>
GET /guilds/{guild_id}/emojis#

List guild emojis

Route<PathParameters<GuildIdPath>, GuildEmojiWithUserListResponse>Route<
  PathParameters<GuildIdPath>,
  GuildEmojiWithUserListResponse
>
GET /guilds/{guild_id}/invites#

List guild invites

Route<PathParameters<GuildIdPath>, InviteMetadataListResponse>Route<
  PathParameters<GuildIdPath>,
  InviteMetadataListResponse
>
GET /guilds/{guild_id}/members#
Route<
    & PathParameters<GuildIdPath>
    & QueryParameters<
          {
              readonly after?: SnowflakeType
              readonly limit?: number
          }
      >,
    GuildMemberListResponse
>Route<
  & PathParameters<GuildIdPath>
  & QueryParameters<
      {
        readonly after?: SnowflakeType
        readonly limit?: number
      }
    >,
  GuildMemberListResponse
>
GET /guilds/{guild_id}/members/{user_id}#

Get guild member by user ID

Route<PathParameters<GuildIdUserIdPath>, GuildMemberResponse>Route<
  PathParameters<GuildIdUserIdPath>,
  GuildMemberResponse
>
GET /guilds/{guild_id}/members/@me#

Get current user guild member

Route<PathParameters<GuildIdPath>, GuildMemberResponse>Route<
  PathParameters<GuildIdPath>,
  GuildMemberResponse
>
GET /guilds/{guild_id}/roles#
Route<PathParameters<GuildIdPath>, GuildRoleListResponse>Route<
  PathParameters<GuildIdPath>,
  GuildRoleListResponse
>
GET /guilds/{guild_id}/stickers#

List guild stickers

Route<PathParameters<GuildIdPath>, GuildStickerWithUserListResponse>Route<
  PathParameters<GuildIdPath>,
  GuildStickerWithUserListResponse
>
GET /guilds/{guild_id}/threads/active#

List active guild threads

Route<PathParameters<GuildIdPath>, ActiveThreadsResponse>Route<
  PathParameters<GuildIdPath>,
  ActiveThreadsResponse
>
GET /guilds/{guild_id}/vanity-url#

Get guild vanity URL

Route<PathParameters<GuildIdPath>, GuildVanityURLResponse>Route<
  PathParameters<GuildIdPath>,
  GuildVanityURLResponse
>
GET /guilds/{guild_id}/webhooks#
Route<PathParameters<GuildIdPath>, WebhookListResponse>Route<
  PathParameters<GuildIdPath>,
  WebhookListResponse
>
GET /oauth2/applications/@me#

Get current applications endpoint

Route<{ … }, OAuth2ApplicationsMeResponse>Route<
  { … },
  OAuth2ApplicationsMeResponse
>
GET /stickers/{sticker_id}/metadata#

Get sticker metadata

Route<PathParameters<StickerIdPath>, GuildStickerMetadataResponse>Route<
  PathParameters<StickerIdPath>,
  GuildStickerMetadataResponse
>
GET /stickers/{sticker_id}/source#

Get sticker source guild

Route<
    PathParameters<StickerIdPath>,
    GuildExpressionSourceGuildResponse
>Route<
  PathParameters<StickerIdPath>,
  GuildExpressionSourceGuildResponse
>
GET /users/{target_id}/profile#

Get user profile

Route<
    & PathParameters<TargetIdPath>
    & QueryParameters<
          {
              readonly guild_id?: SnowflakeType
              readonly with_mutual_friends?: boolean
              readonly with_mutual_guilds?: boolean
          }
      >,
    UserProfileFullResponse
>Route<
  & PathParameters<TargetIdPath>
  & QueryParameters<
      {
        readonly guild_id?:
          SnowflakeType
        readonly with_mutual_friends?:
          boolean
        readonly with_mutual_guilds?:
          boolean
      }
    >,
  UserProfileFullResponse
>
GET /users/{user_id}#

Get user by ID

Route<PathParameters<UserIdPath>, UserPartialResponse>Route<
  PathParameters<UserIdPath>,
  UserPartialResponse
>
GET /users/@me#

Get current user profile

Route<{ … }, UserPrivateResponse>
GET /users/@me/channels#

List private channels

Route<{ … }, ChannelListResponse>
GET /users/@me/guilds#

List current user guilds

Route<
    QueryParameters<
        {
            readonly after?: SnowflakeType
            readonly before?: SnowflakeType
            readonly limit?: number
            readonly with_counts?: boolean
        }
    >,
    GuildListResponse
>Route<
  QueryParameters<
    {
      readonly after?: SnowflakeType
      readonly before?: SnowflakeType
      readonly limit?: number
      readonly with_counts?: boolean
    }
  >,
  GuildListResponse
>
GET /users/check-tag#

Check username tag availability

Route<
    RequiredQueryParameters<
        {
            readonly discriminator: DiscriminatorType
            readonly username: string
        }
    >,
    UserTagCheckResponse
>Route<
  RequiredQueryParameters<
    {
      readonly discriminator:
        DiscriminatorType
      readonly username: string
    }
  >,
  UserTagCheckResponse
>
GET /webhooks/{webhook_id}#
Route<PathParameters<WebhookIdPath>, WebhookResponse>Route<
  PathParameters<WebhookIdPath>,
  WebhookResponse
>
PATCH /channels/{channel_id}#

Update channel settings

Route<
    & PathParameters<ChannelIdPath>
    & OptionalJsonBody<ChannelUpdateRequestBody>,
    ChannelResponse
>Route<
  & PathParameters<ChannelIdPath>
  & OptionalJsonBody<
      ChannelUpdateRequestBody
    >,
  ChannelResponse
>
PATCH /channels/{channel_id}/messages/{message_id}#

Edit a message

Route<
    & PathParameters<ChannelIdMessageIdPath>
    & JsonBody<MessageUpdateRequestSchema>
    & MessageFiles,
    MessageResponseSchema
>Route<
  & PathParameters<
      ChannelIdMessageIdPath
    >
  & JsonBody<
      MessageUpdateRequestSchema
    >
  & MessageFiles,
  MessageResponseSchema
>
PATCH /guilds/{guild_id}#

Update guild settings

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<GuildUpdateRequest>,
    GuildResponse
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      GuildUpdateRequest
    >,
  GuildResponse
>
PATCH /guilds/{guild_id}/channels#

Update channel positions

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<ChannelPositionUpdateRequest>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      ChannelPositionUpdateRequest
    >,
  undefined
>
PATCH /guilds/{guild_id}/discovery#

Edit discovery application

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<DiscoveryApplicationPatchRequest>,
    DiscoveryApplicationResponse
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      DiscoveryApplicationPatchRequest
    >,
  DiscoveryApplicationResponse
>
PATCH /guilds/{guild_id}/emojis/{emoji_id}#

Update guild emoji

Route<
    & PathParameters<GuildIdEmojiIdPath>
    & JsonBody<GuildEmojiUpdateRequest>,
    GuildEmojiResponse
>Route<
  & PathParameters<GuildIdEmojiIdPath>
  & JsonBody<GuildEmojiUpdateRequest>,
  GuildEmojiResponse
>
PATCH /guilds/{guild_id}/members/{user_id}#

Update guild member

Route<
    & PathParameters<GuildIdUserIdPath>
    & OptionalJsonBody<GuildMemberUpdateRequest>,
    GuildMemberResponse
>Route<
  & PathParameters<GuildIdUserIdPath>
  & OptionalJsonBody<
      GuildMemberUpdateRequest
    >,
  GuildMemberResponse
>
PATCH /guilds/{guild_id}/members/@me#

Update current user guild member

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<MyGuildMemberUpdateRequest>,
    GuildMemberResponse
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      MyGuildMemberUpdateRequest
    >,
  GuildMemberResponse
>
PATCH /guilds/{guild_id}/roles#

Update role positions

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildRolePositionsRequest>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildRolePositionsRequest
    >,
  undefined
>
PATCH /guilds/{guild_id}/roles/{role_id}#

Update guild role

Route<
    & PathParameters<GuildIdRoleIdPath>
    & OptionalJsonBody<GuildRoleUpdateRequest>,
    GuildRoleResponse
>Route<
  & PathParameters<GuildIdRoleIdPath>
  & OptionalJsonBody<
      GuildRoleUpdateRequest
    >,
  GuildRoleResponse
>
PATCH /guilds/{guild_id}/roles/hoist-positions#

Update role hoist positions

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildRoleHoistPositionsRequest>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildRoleHoistPositionsRequest
    >,
  undefined
>
PATCH /guilds/{guild_id}/stickers/{sticker_id}#

Update guild sticker

Route<
    & PathParameters<GuildIdStickerIdPath>
    & JsonBody<GuildStickerUpdateRequest>,
    GuildStickerResponse
>Route<
  & PathParameters<
      GuildIdStickerIdPath
    >
  & JsonBody<
      GuildStickerUpdateRequest
    >,
  GuildStickerResponse
>
PATCH /guilds/{guild_id}/vanity-url#

Update guild vanity URL

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<GuildVanityURLUpdateRequest>,
    GuildVanityURLUpdateResponse
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      GuildVanityURLUpdateRequest
    >,
  GuildVanityURLUpdateResponse
>
PATCH /webhooks/{webhook_id}#

Update webhook

Route<
    & PathParameters<WebhookIdPath>
    & OptionalJsonBody<WebhookUpdateRequest>,
    WebhookResponse
>Route<
  & PathParameters<WebhookIdPath>
  & OptionalJsonBody<
      WebhookUpdateRequest
    >,
  WebhookResponse
>
POST /attachments/refresh-urls#

Refresh attachment URLs

Route<
    JsonBody<RefreshAttachmentUrlsRequest>,
    RefreshAttachmentUrlsResponse
>Route<
  JsonBody<
    RefreshAttachmentUrlsRequest
  >,
  RefreshAttachmentUrlsResponse
>
POST /auth/logout#

Logout account

Route<{ … }, undefined>
POST /channels/{channel_id}/attachments#

Request presigned attachment upload URLs

Route<
    & PathParameters<ChannelIdPath>
    & JsonBody<PresignedAttachmentUploadRequest>,
    PresignedAttachmentUploadResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<
      PresignedAttachmentUploadRequest
    >,
  PresignedAttachmentUploadResponse
>
POST /channels/{channel_id}/attachments/complete#

Finalize multipart attachment uploads

Route<
    & PathParameters<ChannelIdPath>
    & JsonBody<CompleteMultipartAttachmentUploadRequest>,
    CompleteMultipartAttachmentUploadResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<
      CompleteMultipartAttachmentUploadRequest
    >,
  CompleteMultipartAttachmentUploadResponse
>
POST /channels/{channel_id}/followers#

Follow an announcement channel

Route<
    PathParameters<ChannelIdPath> & JsonBody<ChannelFollowRequest>,
    FollowedChannelResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<ChannelFollowRequest>,
  FollowedChannelResponse
>
POST /channels/{channel_id}/invites#

Create channel invite

Route<
    & PathParameters<ChannelIdPath>
    & OptionalJsonBody<ChannelInviteCreateRequest>,
    InviteMetadataResponseSchema
>Route<
  & PathParameters<ChannelIdPath>
  & OptionalJsonBody<
      ChannelInviteCreateRequest
    >,
  InviteMetadataResponseSchema
>
POST /channels/{channel_id}/messages#

Send a message

Route<
    & PathParameters<ChannelIdPath>
    & JsonBody<MessageRequestSchema>
    & MessageFiles,
    MessageResponseSchema
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<MessageRequestSchema>
  & MessageFiles,
  MessageResponseSchema
>
POST /channels/{channel_id}/messages/{message_id}/crosspost#

Publish a message to following channels

Route<PathParameters<ChannelIdMessageIdPath>, MessageResponseSchema>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  MessageResponseSchema
>
POST /channels/{channel_id}/messages/{message_id}/threads#

Start a thread from a message

Route<
    & PathParameters<ChannelIdMessageIdPath>
    & JsonBody<StartThreadFromMessageRequest>,
    ThreadChannelResponse
>Route<
  & PathParameters<
      ChannelIdMessageIdPath
    >
  & JsonBody<
      StartThreadFromMessageRequest
    >,
  ThreadChannelResponse
>
POST /channels/{channel_id}/messages/bulk-delete#

Bulk delete messages

Route<
    & PathParameters<ChannelIdPath>
    & JsonBody<BulkDeleteMessagesRequest>,
    undefined
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<
      BulkDeleteMessagesRequest
    >,
  undefined
>
POST /channels/{channel_id}/messages/bulk-delete-mine#

Bulk delete my messages in channel

Route<
    & PathParameters<ChannelIdPath>
    & OptionalJsonBody<SudoVerificationSchema>,
    undefined
>Route<
  & PathParameters<ChannelIdPath>
  & OptionalJsonBody<
      SudoVerificationSchema
    >,
  undefined
>
POST /channels/{channel_id}/messages/purge#

Purge all messages in personal notes

Route<PathParameters<ChannelIdPath>, MessagePurgeResponse>Route<
  PathParameters<ChannelIdPath>,
  MessagePurgeResponse
>
POST /channels/{channel_id}/pins/ack#

Acknowledge new pin notifications

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
POST /channels/{channel_id}/post-data#

Get forum post data

Route<
    PathParameters<ChannelIdPath> & JsonBody<ThreadPostDataRequest>,
    ThreadPostDataResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<ThreadPostDataRequest>,
  ThreadPostDataResponse
>
POST /channels/{channel_id}/tags#

Create a forum tag

Route<
    PathParameters<ChannelIdPath> & JsonBody<ForumTagRequest>,
    ChannelResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<ForumTagRequest>,
  ChannelResponse
>
POST /channels/{channel_id}/threads#

Start a thread

Route<
    & PathParameters<ChannelIdPath>
    & JsonBody<StartThreadRequestBody>,
    StartForumThreadResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<StartThreadRequestBody>,
  StartForumThreadResponse
>
POST /channels/{channel_id}/typing#

Indicate typing activity

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
POST /channels/{channel_id}/webhooks#

Create webhook

Route<
    PathParameters<ChannelIdPath> & JsonBody<WebhookCreateRequest>,
    WebhookCreateResponse
>Route<
  & PathParameters<ChannelIdPath>
  & JsonBody<WebhookCreateRequest>,
  WebhookCreateResponse
>
POST /guilds/{guild_id}/channels#

Create guild channel

Route<
    PathParameters<GuildIdPath> & JsonBody<ChannelCreateRequest>,
    ChannelResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<ChannelCreateRequest>,
  ChannelResponse
>
POST /guilds/{guild_id}/delete#

Delete guild

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<GuildDeleteRequest>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      GuildDeleteRequest
    >,
  undefined
>
POST /guilds/{guild_id}/discovery#

Apply for guild discovery

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<DiscoveryApplicationRequest>,
    DiscoveryApplicationResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      DiscoveryApplicationRequest
    >,
  DiscoveryApplicationResponse
>
POST /guilds/{guild_id}/emojis#

Create guild emoji

Route<
    PathParameters<GuildIdPath> & JsonBody<GuildEmojiCreateRequest>,
    GuildEmojiResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<GuildEmojiCreateRequest>,
  GuildEmojiResponse
>
POST /guilds/{guild_id}/emojis/bulk#

Bulk create guild emojis

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildEmojiBulkCreateRequest>,
    GuildEmojiBulkCreateResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildEmojiBulkCreateRequest
    >,
  GuildEmojiBulkCreateResponse
>
POST /guilds/{guild_id}/emojis/clone#

Clone guild emoji

Route<
    PathParameters<GuildIdPath> & JsonBody<GuildEmojiCloneRequest>,
    GuildEmojiResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<GuildEmojiCloneRequest>,
  GuildEmojiResponse
>
POST /guilds/{guild_id}/members-search#

Search guild members

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<GuildMemberSearchRequest>,
    GuildMemberSearchResponse
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      GuildMemberSearchRequest
    >,
  GuildMemberSearchResponse
>
POST /guilds/{guild_id}/roles#

Create guild role

Route<
    PathParameters<GuildIdPath> & JsonBody<GuildRoleCreateRequest>,
    GuildRoleResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<GuildRoleCreateRequest>,
  GuildRoleResponse
>
POST /guilds/{guild_id}/stickers#

Create guild sticker

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildStickerCreateRequest>,
    GuildStickerResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildStickerCreateRequest
    >,
  GuildStickerResponse
>
POST /guilds/{guild_id}/stickers/bulk#

Bulk create guild stickers

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildStickerBulkCreateRequest>,
    GuildStickerBulkCreateResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildStickerBulkCreateRequest
    >,
  GuildStickerBulkCreateResponse
>
POST /guilds/{guild_id}/stickers/clone#

Clone guild sticker

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildStickerCloneRequest>,
    GuildStickerResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildStickerCloneRequest
    >,
  GuildStickerResponse
>
POST /guilds/{guild_id}/transfer-ownership#

Transfer guild ownership

Route<
    & PathParameters<GuildIdPath>
    & JsonBody<GuildTransferOwnershipWithVerificationRequest>,
    GuildResponse
>Route<
  & PathParameters<GuildIdPath>
  & JsonBody<
      GuildTransferOwnershipWithVerificationRequest
    >,
  GuildResponse
>
POST /search/messages#

Search messages

Route<
    OptionalJsonBody<GlobalSearchMessagesRequest>,
    MessageSearchResponse
>Route<
  OptionalJsonBody<
    GlobalSearchMessagesRequest
  >,
  MessageSearchResponse
>
POST /users/@me/channels#

Create private channel

Route<JsonBody<CreatePrivateChannelRequest>, ChannelResponse>Route<
  JsonBody<
    CreatePrivateChannelRequest
  >,
  ChannelResponse
>
POST /users/@me/channels/messages/preload#

Preload messages for channels (alternative)

Route<JsonBody<PreloadMessagesRequest>, PreloadMessagesResponse>Route<
  JsonBody<PreloadMessagesRequest>,
  PreloadMessagesResponse
>
POST /users/@me/guilds/{guild_id}/messages/bulk-delete-mine#

Bulk delete my messages in guild

Route<
    & PathParameters<GuildIdPath>
    & OptionalJsonBody<SudoVerificationSchema>,
    undefined
>Route<
  & PathParameters<GuildIdPath>
  & OptionalJsonBody<
      SudoVerificationSchema
    >,
  undefined
>
POST /users/@me/preload-messages#

Preload messages for channels

Route<JsonBody<PreloadMessagesRequest>, PreloadMessagesResponse>Route<
  JsonBody<PreloadMessagesRequest>,
  PreloadMessagesResponse
>
PUT /channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me#

Add reaction to message

Route<
    & PathParameters<ChannelIdMessageIdEmojiPath>
    & QueryParameters<{ readonly session_id?: string }>,
    undefined
>Route<
  & PathParameters<
      ChannelIdMessageIdEmojiPath
    >
  & QueryParameters<
      { readonly session_id?: string }
    >,
  undefined
>
PUT /channels/{channel_id}/permissions/{overwrite_id}#

Set permission overwrite for channel

Route<
    & PathParameters<ChannelIdOverwriteIdPath>
    & JsonBody<PermissionOverwriteCreateRequest>,
    undefined
>Route<
  & PathParameters<
      ChannelIdOverwriteIdPath
    >
  & JsonBody<
      PermissionOverwriteCreateRequest
    >,
  undefined
>
PUT /channels/{channel_id}/pins/{message_id}#

Pin a message

Route<PathParameters<ChannelIdMessageIdPath>, undefined>Route<
  PathParameters<
    ChannelIdMessageIdPath
  >,
  undefined
>
PUT /channels/{channel_id}/recipients/{user_id}#

Add recipient to group DM

Route<PathParameters<ChannelIdUserIdPath>, undefined>Route<
  PathParameters<ChannelIdUserIdPath>,
  undefined
>
PUT /channels/{channel_id}/tags/{tag_id}#

Update a forum tag

Route<
    PathParameters<ChannelIdTagIdPath> & JsonBody<ForumTagRequest>,
    ChannelResponse
>Route<
  & PathParameters<ChannelIdTagIdPath>
  & JsonBody<ForumTagRequest>,
  ChannelResponse
>
PUT /channels/{channel_id}/thread-members/{user_id}#

Add a thread member

Route<PathParameters<ChannelIdUserIdPath>, undefined>Route<
  PathParameters<ChannelIdUserIdPath>,
  undefined
>
PUT /channels/{channel_id}/thread-members/@me#

Join a thread

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>
PUT /guilds/{guild_id}/bans/{user_id}#
Route<
    & PathParameters<GuildIdUserIdPath>
    & OptionalJsonBody<GuildBanCreateRequest>,
    undefined
>Route<
  & PathParameters<GuildIdUserIdPath>
  & OptionalJsonBody<
      GuildBanCreateRequest
    >,
  undefined
>
PUT /guilds/{guild_id}/members/{user_id}/roles/{role_id}#
Route<PathParameters<GuildIdUserIdRoleIdPath>, undefined>Route<
  PathParameters<
    GuildIdUserIdRoleIdPath
  >,
  undefined
>
PUT /users/@me/channels/{channel_id}/pin#

Pin direct message channel

Route<PathParameters<ChannelIdPath>, undefined>Route<
  PathParameters<ChannelIdPath>,
  undefined
>