Regex expressions for split_message to not break Discord formatting.

A Discord guild (server). Can either be an UnavailableGuild or a Guild.

A User activity. More details here.

Fields

name           :: String
type           :: Int
url            :: OptionalNullable{String}
timestamps     :: Optional{Ekztazy.ActivityTimestamps}
application_id :: Optional{Snowflake}
details        :: OptionalNullable{String}
state          :: OptionalNullable{String}
emoji          :: OptionalNullable{Ekztazy.ActivityEmoji}
party          :: Optional{Ekztazy.ActivityParty}
assets         :: Optional{Ekztazy.ActivityAssets}
secrets        :: Optional{Ekztazy.ActivitySecrets}
instance       :: Optional{Bool}
flags          :: Optional{Int}

Images and hover text for an Activity. More details here.

Fields

large_image :: Optional{String}
large_text  :: Optional{String}
small_image :: Optional{String}
small_text  :: Optional{String}

Emoji for a custom Activity. More details here.

Fields

name     :: String
id       :: Optional{Snowflake}
animated :: Optional{Bool}

The current party of an Activity's player. More details here.

Fields

id   :: Optional{String}
size :: Optional{Vector{Int}}

Secrets for Rich Presence joining and spectating of an Activity. More details here.

Fields

join     :: Optional{String}
spectate :: Optional{String}
match    :: Optional{String}

The start and stop times of an Activity. More details here.

Fields

start :: Optional{DateTime}
stop  :: Optional{DateTime}

An Application Command. More details here.

Fields

id                  :: OptionalNullable{Snowflake}
type                :: Optional{Int}
application_id      :: Snowflake
guild_id            :: Optional{Snowflake}
name                :: String
description         :: String
options             :: Optional{Vector{Ekztazy.ApplicationCommandOption}}
default_permissions :: Optional{Bool}
version             :: Optional{Snowflake}

Application Command Choice. More details here.

Fields

name  :: String
value :: Union{Number, String}

Application Command Option. More details here.

Fields

value         :: Any
type          :: Optional{Int}
name          :: Optional{String}
description   :: Optional{String}
required      :: Optional{Bool}
min_value     :: Optional{Number}
max_value     :: Optional{Number}
autocomplete  :: Optional{Bool}
choices       :: Optional{Vector{Ekztazy.ApplicationCommandChoice}}
options       :: Optional{Vector{Ekztazy.ApplicationCommandOption}}
channel_types :: Optional{Vector{Int}}
focused       :: Optional{Bool}

A Message attachment. More details here.

Fields

id        :: Snowflake
filename  :: String
size      :: Int
url       :: String
proxy_url :: String
height    :: Optional{Int}
width     :: Optional{Int}

An audit log. More details here.

Fields

webhooks          :: Vector{Ekztazy.Webhook}
users             :: Vector{Ekztazy.User}
audit_log_entries :: Vector{Ekztazy.AuditLogEntry}

A change item in an AuditLogEntry.

The first type parameter is the type of new_value and old_value. The second is the type of the entity that new_value and old_value belong(ed) to.

More details here.

Fields

new_value :: Optional{T} where T
old_value :: Optional{T} where T
key       :: String
type      :: Type{U} where U

An entry in an AuditLog. More details here.

Fields

target_id   :: Nullable{Snowflake}
changes     :: Optional{Vector{Ekztazy.AuditLogChange}}
user_id     :: Snowflake
id          :: Snowflake
action_type :: Int
options     :: Optional{Ekztazy.AuditLogOptions}
reason      :: Optional{String}

Optional information in an AuditLogEntry. More details here.

Fields

delete_member_days :: Optional{Int}
members_removed    :: Optional{Int}
channel_id         :: Optional{Snowflake}
count              :: Optional{Int}
id                 :: Optional{Snowflake}
type               :: Optional{Int}
role_name          :: Optional{String}

A User ban. More details here.

Fields

reason :: Nullable{String}
user   :: Ekztazy.User

CacheFilter(f::Function) -> CacheFilter

Only store value v at key k if f(v) === true (k is always v.id).

CacheForever() -> CacheForever

Store everything and never evict items from the cache.

CacheLRU(size::Int) -> CacheLRU

Evict the least recently used item from the cache when there are more than size items.

CacheNever() -> CacheNever

Don't store anything in the cache.

A method of handling cache insertion and eviction.

CacheTTL(ttl::Period) -> CacheTTL

Evict items from the cache after ttl has elapsed.

Client(
    token::String
    application_id::Snowflake
    intents::Int;
    presence::Union{Dict, NamedTuple}=Dict(),
    strategies::Dict{DataType, <:CacheStrategy}=Dict(),
    version::Int=9,
) -> Client

A Discord bot. Clients can connect to the gateway, respond to events, and make REST API calls to perform actions such as sending/deleting messages, kicking/banning users, etc.

Bot Token

A bot token can be acquired by creating a new application here. Make sure not to hardcode the token into your Julia code! Use an environment variable or configuration file instead.

Application ID

The application id for your bot can be found here. Make sure not to hardcode the application id into your Julia code! Use an environment variable or configuration file instead.

Intents

Integer representing intents. More information here.

Presence

The presence keyword sets the bot's presence upon connection. It also sets defaults for future calls to set_game. The schema here must be followed.

Cache Control

By default, most data that comes from Discord is cached for later use. However, to avoid memory leakage, not all of it is kept forever. The default setings are to keep everything but Messages, which are deleted after 6 hours, forever. Although the default settings are sufficient for most workloads, you can specify your own strategies per type with the strategies keyword. Keys can be any of the following:

• Guild
• DiscordChannel
• Message
• User
• Member
• Presence

For potential values, see CacheStrategy.

The cache can also be disabled/enabled permanently and temporarily as a whole with enable_cache! and disable_cache!.

API Version

The version keyword chooses the Version of the Discord API to use. Using anything but 9 is not officially supported by the Ekztazy.jl developers.

Sharding

Sharding is handled automatically. The number of available processes is the number of shards that are created. See the sharding example for more details.

An interactable component. More details here.

Fields

type        :: Int
custom_id   :: Optional{String}
value       :: Optional{String}
disabled    :: Optional{Bool}
style       :: Optional{Int}
label       :: Optional{String}
emoji       :: Optional{Ekztazy.Emoji}
url         :: Optional{String}
options     :: Optional{Vector{Ekztazy.SelectOption}}
placeholder :: Optional{String}
min_values  :: Optional{Int}
max_values  :: Optional{Int}
components  :: Optional{Vector{Ekztazy.Component}}

A User connection to an external service (Twitch, YouTube, etc.). More details here.

Fields

id           :: String
name         :: String
type         :: String
revoked      :: Bool
integrations :: Vector{Ekztazy.Integration}

Context(
    data::Dict{Symbol, Any}
)

Context is a wrapper for a Dict{Symbol, Any} with some special functionality.

Context(; kwargs...) -> Context

Generates a context based on kwargs.

A Discord channel. More details here.

Note: The name Channel is already used, hence the prefix.

Fields

id                    :: Snowflake
type                  :: Optional{Int}
guild_id              :: Optional{Snowflake}
position              :: Optional{Int}
permission_overwrites :: Optional{Vector{Ekztazy.Overwrite}}
name                  :: Optional{String}
topic                 :: OptionalNullable{String}
nsfw                  :: Optional{Bool}
last_message_id       :: OptionalNullable{Snowflake}
bitrate               :: Optional{Int}
user_limit            :: Optional{Int}
rate_limit_per_user   :: Optional{Int}
recipients            :: Optional{Vector{Ekztazy.User}}
icon                  :: OptionalNullable{String}
owner_id              :: Optional{Snowflake}
application_id        :: Optional{Snowflake}
parent_id             :: OptionalNullable{Snowflake}
last_pin_timestamp    :: OptionalNullable{DateTime}

A Message embed. More details here.

Fields

title       :: Optional{String}
type        :: Optional{String}
description :: Optional{String}
url         :: Optional{String}
timestamp   :: Optional{DateTime}
color       :: Optional{Int}
footer      :: Optional{Ekztazy.EmbedFooter}
image       :: Optional{Ekztazy.EmbedImage}
thumbnail   :: Optional{Ekztazy.EmbedThumbnail}
video       :: Optional{Ekztazy.EmbedVideo}
provider    :: Optional{Ekztazy.EmbedProvider}
author      :: Optional{Ekztazy.EmbedAuthor}
fields      :: Optional{Vector{Ekztazy.EmbedField}}

An Embed's author information. More details here.

Fields

name           :: Optional{String}
url            :: Optional{String}
icon_url       :: Optional{String}
proxy_icon_url :: Optional{String}

An Embed field. More details here.

Fields

name   :: String
value  :: String
inline :: Optional{Bool}

An Embed's footer information. More details here.

Fields

text           :: String
icon_url       :: Optional{String}
proxy_icon_url :: Optional{String}

An Embed's image information. More details here.

Fields

url       :: Optional{String}
proxy_url :: Optional{String}
height    :: Optional{Int}
width     :: Optional{Int}

An Embed's provider information. More details here.

Fields

name :: Optional{String}
url  :: OptionalNullable{String}

An Embed's thumbnail image information. More details here.

Fields

url       :: Optional{String}
proxy_url :: Optional{String}
height    :: Optional{Int}
width     :: Optional{Int}

An Embed's video information. More details here.

Fields

url    :: Optional{String}
height :: Optional{Int}
width  :: Optional{Int}

An emoji. More details here.

Fields

id             :: Nullable{Snowflake}
name           :: String
roles          :: Optional{Vector{Snowflake}}
user           :: Optional{Ekztazy.User}
require_colons :: Optional{Bool}
managed        :: Optional{Bool}
animated       :: Optional{Bool}

A Discord guild (server). More details here.

Fields

id                            :: Snowflake
name                          :: String
icon                          :: Nullable{String}
splash                        :: OptionalNullable{String}
owner                         :: Optional{Bool}
owner_id                      :: Optional{Snowflake}
permissions                   :: Optional{String}
region                        :: Optional{String}
afk_channel_id                :: OptionalNullable{Snowflake}
afk_timeout                   :: Optional{Int}
embed_enabled                 :: Optional{Bool}
embed_channel_id              :: OptionalNullable{Snowflake}
verification_level            :: Optional{Int}
default_message_notifications :: Optional{Int}
explicit_content_filter       :: Optional{Int}
roles                         :: Optional{Vector{Ekztazy.Role}}
emojis                        :: Optional{Vector{Ekztazy.Emoji}}
features                      :: Optional{Vector{String}}
mfa_level                     :: Optional{Int}
application_id                :: OptionalNullable{Snowflake}
widget_enabled                :: Optional{Bool}
widget_channel_id             :: OptionalNullable{Snowflake}
system_channel_id             :: OptionalNullable{Snowflake}
joined_at                     :: Optional{DateTime}
large                         :: Optional{Bool}
unavailable                   :: Optional{Bool}
member_count                  :: Optional{Int}
max_members                   :: Optional{Int}
voice_states                  :: Optional{Vector{Ekztazy.VoiceState}}
members                       :: Optional{Vector{Ekztazy.Member}}
channels                      :: Optional{Vector{Ekztazy.DiscordChannel}}
presences                     :: Optional{Vector{Ekztazy.Presence}}
max_presences                 :: OptionalNullable{Int}
vanity_url_code               :: OptionalNullable{String}
description                   :: OptionalNullable{String}
banner                        :: OptionalNullable{String}

A Guild embed. More details here.

Fields

enabled    :: Bool
channel_id :: Nullable{Snowflake}

Handler(
    f::Function
    d::Dict{Symbol, Any}
)

Handler is a wrapper for a Dict{Symbol, Any} that also contains a function.

Handler(; kwargs...) -> Handler

Generates a handler based on kwargs and a function.

A Guild integration. More details here.

Fields

id                  :: Snowflake
name                :: String
type                :: String
enabled             :: Bool
syncing             :: Bool
role_id             :: Snowflake
expire_behaviour    :: Int
expire_grace_period :: Int
user                :: Ekztazy.User
account             :: Ekztazy.IntegrationAccount
synced_at           :: DateTime

An Integration account. More details here.

Fields

id   :: String
name :: String

An interaction. More details here.

Fields

id             :: Nullable{Snowflake}
application_id :: Nullable{Snowflake}
type           :: Int
data           :: OptionalNullable{Ekztazy.InteractionData}
guild_id       :: Optional{Snowflake}
channel_id     :: Optional{Snowflake}
member         :: Optional{Ekztazy.Member}
user           :: Optional{Ekztazy.User}
token          :: String
version        :: Optional{Int}
message        :: Optional{Ekztazy.Message}

Data for an interaction. More details here.

Fields

id             :: OptionalNullable{Snowflake}
name           :: OptionalNullable{String}
type           :: OptionalNullable{Int}
resolved       :: Optional{Ekztazy.ResolvedData}
options        :: Optional{Vector{Ekztazy.ApplicationCommandOption}}
custom_id      :: OptionalNullable{String}
component_type :: OptionalNullable{Int}
components     :: OptionalNullable{Vector{Ekztazy.Component}}
values         :: Optional{Vector{String}}
target_id      :: Optional{Snowflake}

An invite to a Guild. More details here.

Fields

code                       :: String
guild                      :: Optional{Ekztazy.Guild}
channel                    :: Ekztazy.DiscordChannel
approximate_presence_cound :: Optional{Int}
approximate_member_count   :: Optional{Int}

Metadata for an Invite. More details here.

Fields

inviter    :: Ekztazy.User
uses       :: Int
max_uses   :: Int
max_age    :: Int
temporary  :: Bool
created_at :: DateTime
revoked    :: Bool

A Guild member. More details here.

Fields

user          :: Optional{Ekztazy.User}
nick          :: OptionalNullable{String}
roles         :: Vector{Snowflake}
joined_at     :: DateTime
premium_since :: OptionalNullable{DateTime}
deaf          :: Optional{Bool}
mute          :: Optional{Bool}

A message sent to a DiscordChannel. More details here.

Fields

id                :: Snowflake
channel_id        :: Snowflake
guild_id          :: Optional{Snowflake}
author            :: Optional{Ekztazy.User}
member            :: Optional{Ekztazy.Member}
content           :: Optional{String}
timestamp         :: Optional{DateTime}
edited_timestamp  :: OptionalNullable{DateTime}
tts               :: Optional{Bool}
mention_everyone  :: Optional{Bool}
mentions          :: Optional{Vector{Ekztazy.User}}
mention_roles     :: Optional{Vector{Snowflake}}
attachments       :: Optional{Vector{Ekztazy.Attachment}}
message_reference :: Optional{Ekztazy.MessageReference}
embeds            :: Optional{Vector{Ekztazy.Embed}}
reactions         :: Optional{Vector{Ekztazy.Reaction}}
nonce             :: OptionalNullable{Snowflake}
pinned            :: Optional{Bool}
webhook_id        :: Optional{Snowflake}
type              :: Optional{Int}
activity          :: Optional{Ekztazy.MessageActivity}
application       :: Optional{Ekztazy.MessageApplication}

A Message activity. More details here.

Fields

type     :: Int
party_id :: Optional{String}

A Rich Presence Message's application information. More details here.

Fields

id          :: Snowflake
cover_image :: Optional{String}
description :: String
icon        :: String
name        :: String

A permission overwrite. More details here.

Fields

id    :: Snowflake
type  :: Int
allow :: String
deny  :: String

Bitwise permission flags. More details here.

A User's presence. More details here.

Fields

user       :: Ekztazy.User
roles      :: Optional{Vector{Snowflake}}
game       :: Nullable{Ekztazy.Activity}
guild_id   :: Optional{Snowflake}
status     :: String
activities :: Vector{Ekztazy.Activity}

A Message reaction. More details here.

Fields

count :: Int
me    :: Bool
emoji :: Ekztazy.Emoji

A wrapper around a response from the REST API. Every function which wraps a Discord REST API endpoint returns a Future which will contain a value of this type. To retrieve the Response from the Future, use fetch. See also: fetchval.

Fields

• val::Nullable{T}: The object contained in the HTTP response. For example, for a call to get_channel_message, this value will be a Message.
• ok::Bool: The state of the request. If true, then it is safe to access val.
• http_response::Nullable{HTTP.Messages.Response}: The underlying HTTP response, if a request was made.
• exception::Nullable{Exception}: The caught exception, if one is thrown.

Examples

Multiple API calls which immediately return Futures and can be awaited:

futures = map(i -> create_message(c, channel_id; content=string(i)), 1:10);
other_work_here()
resps = fetch.(futures)

Skipping error checks and returning the value directly:

guild = fetchval(create_guild(c; name="foo"))

A User role. More details here.

Fields

id          :: Snowflake
name        :: String
color       :: Optional{Int}
hoist       :: Optional{Bool}
position    :: Optional{Int}
permissions :: Optional{String}
managed     :: Optional{Bool}
mentionable :: Optional{Bool}

A select option. More details here.

Fields

label       :: String
value       :: String
description :: Optional{String}
emoji       :: Optional{Ekztazy.Emoji}
default     :: Optional{Bool}

An unavailable Discord guild (server). More details here.

Fields

id          :: Snowflake
unavailable :: Optional{Bool}

A Discord user. More details here.

Fields

id            :: Snowflake
username      :: Optional{String}
discriminator :: Optional{String}
avatar        :: OptionalNullable{String}
bot           :: Optional{Bool}
mfa_enabled   :: Optional{Bool}
locale        :: Optional{String}
verified      :: Optional{Bool}
email         :: OptionalNullable{String}

A region for a Guild's voice server. More details here.

Fields

id         :: String
name       :: String
vip        :: Bool
optimal    :: Bool
deprecated :: Bool
custom     :: Bool

A User's voice connection status. More details here.

Fields

guild_id   :: Optional{Snowflake}
channel_id :: Nullable{Snowflake}
user_id    :: Snowflake
member     :: Optional{Ekztazy.Member}
session_id :: String
deaf       :: Bool
mute       :: Bool
self_deaf  :: Bool
self_mute  :: Bool
suppress   :: Bool

A Webhook. More details here.

Fields

id         :: Snowflake
guild_id   :: Optional{Snowflake}
channel_id :: Snowflake
user       :: Optional{Ekztazy.User}
name       :: Nullable{String}
avatar     :: Nullable{String}
token      :: Optional{String}

close(c::Client)

Disconnect the Client from the gateway.

isopen(c::Client) -> Bool

Determine whether the Client is connected to the gateway.

open(c::Client; delay::Period=Second(7))

Connect a Client to the Discord gateway.

The delay keyword is the time between shards connecting. It can be increased from its default if you are using multiple shards and frequently experiencing invalid sessions upon connection.

wait(c::Client)

Wait for an open Client to close.

Option(; kwargs...) -> ApplicationCommandOption

Helper function that creates an ApplicationCommandOption`

Options(args...) -> Vector{ApplicationCommandOption}

Calls Option on each Vector in the args.

ack_interaction(c::Client, int_id::Snowflake, int_token::String; kwargs...)

Respond to an interaction with code 5.

add_guild_member(c::Client; kwargs...) -> Member

Add a User to a Guild. More details here.

add_guild_member_role(c::Client, guild::Integer, user::Integer, role::Integer)

Add a Role to a Member.

add_handler!(c::Client, handler::Handler)

Adds a handler to the client.

add_handler!(c::Client, handler::Handler)

Bulk adds handlers to the client.

add_pinned_channel_message(c::Client, channel::Integer, message::Integer)

Pin a Message in a DiscordChannel.

begin_guild_prune(c::Client, guild::Integer; kwargs...) -> Dict

Begin pruning Members from a Guild. More details here.

bulk_delete_messages(c::Client, channel::Integer; kwargs...)

Delete multiple Messages. More details here.

bulk_overwrite_application_commands(c::Client, guild::Snowflake, cmds::Vector{ApplicationCommand}) -> Vector{ApplicationCommand}

Overwrites global ApplicationCommands with the given cmds vector.

bulk_overwrite_application_commands(c::Client, guild::Snowflake, cmds::Vector{ApplicationCommand}) -> Vector{ApplicationCommand}

Overwrites guild ApplicationCommands with the given cmds vector.

command!(
    f::Function
    c::Client
    name::AbstractString
    description::AbstractString;
    kwargs...
)

Adds a handler for INTERACTION CREATE gateway events where the InteractionData's name field matches name. Adds this command to c.commands or c.guild_commands based on the presence of guild. The f parameter signature should be:

    (ctx::Context, args...) -> Any 

Where args is a list of all the Command Options

For example a command that takes a user u and a number n as input should have this signature:

(ctx::Context, u::User, n::Int) -> Any

and the arguments would automatically get converted.

Note: The argument names must match the Option names. The arguments can be ordered in any way. If no type is specified, no conversion will be performed, so Discord objects will be Snowflakes.

component!(
    f::Function
    c::Client
    custom_id::AbstractString
    kwargs...
)

Adds a handler for INTERACTION CREATE gateway events where the InteractionData's custom_id field matches custom_id. The f parameter signature should be:

(ctx::Context) -> Any 

context(t::Symbol, data::Dict{Symbol, Any}) -> Context

Checks if the Context needs to be created in a special way based on the event provided by t.

Then, returns the generated context.

create(c::Client, ::Type{T}, args...; kwargs...) -> Future{Response}

Create, add, send, etc.

Examples

Sending a Message:

create(c, Message, channel; content="foo")

Creating a new DiscordChannel:

create(c, DiscordChannel, guild; name="bar")

Banning a Member:

create(c, Ban, guild, member; reason="baz")

create_application_command(c::Client, guild::Snowflake; kwargs...) -> ApplicationCommand

Creates a guild ApplicationCommand.

create_application_command(c::Client; kwargs...) -> ApplicationCommand

Creates a global ApplicationCommand.

create_channel_invite(c::Client, channel::Integer; kwargs...) -> Invite

Create an Invite to a DiscordChannel. More details here.

create_dm(c::Client; kwargs...) -> DiscordChannel

Create a DM DiscordChannel. More details here.

create_followup_message(c::Client, int_id::Snowflake, int_token::String; kwargs...) -> Message

Creates a followup message for an interaction.

create_guild(c::Client; kwargs...) -> Guild

Create a Guild. More details here.

create_guild_ban(c::Client, guild::Integer, user::Integer; kwargs...)

Ban a Member from a Guild. More details here.

create_guild_channel(c::Client, guild::Integer; kwargs...) -> DiscordChannel

Create a DiscordChannel in a Guild. More details here.

create_guild_emoji(c::Client, guild::Integer; kwargs...) -> Emoji

Create an Emoji in a Guild. More details here.

create_guild_integration(c::Client, guild::Integer; kwargs...)

Create/attach an Integration to a Guild. More details here.

create_guild_role(c::Client, guild::Integer; kwargs) -> Role

Create a Role in a Guild. More details here.

create_message(c::Client, channel::Integer; kwargs...) -> Message

Send a Message to a DiscordChannel. More details here.

create_reaction(c::Client, channel::Integer, message::Integer, emoji::StringOrChar)

React to a Message. If emoji is a custom Emoji, it should be formatted "name:id".

create_webhook(c::Client, channel::Integer; kwargs...) -> Webhook

Create a Webhook in a DiscordChannel. More details here.

delete(c::Client, x::T, args...) -> Future{Response}

Delete, remove, discard, etc.

Examples

Kicking a Member:

delete(c, member)

Unbanning a Member:

delete(c, ban, guild)

Deleting all Reactions from a Message (note: this is the only update/delete method which takes a type parameter):

delete(c, Reaction, message)

delete_all_reactions(c::Client, channel::Integer, message::Integer)

Delete all reactions from a Message.

delete_channel(c::Client, channel::Integer) -> DiscordChannel

Delete a DiscordChannel.

delete_channel_permission(c::Client, channel::Integer, overwrite::Integer)

Delete an Overwrite from a DiscordChannel.

delete_guild(c::Client, guild::Integer)

Delete a Guild.

delete_guild_emoji(c::Client, guild::Integer, emoji::Integer)

Delete an Emoji from a Guild.

delete_guild_integration(c::Client, guild::Integer, integration::Integer)

Delete an Integration from a Guild.

delete_guild_role(c::Client, guild::Integer, role::Integer)

Delete a Role from a Guild.

delete_invite(c::Client, invite::AbstractString) -> Invite

Delete an Invite to a Guild.

delete_message(c::Client, channel::Integer, message::Integer)

Delete a Message.

delete_own_reaction(c::Client, channel::Integer, message::Integer, emoji::StringOrChar)

Delete the Client user's reaction to a Message.

delete_pinned_channel_message(c::Client, channel::Integer, message::Integer)

Unpin a Message from a DiscordChannel.

delete_user_reaction(
    c::Client,
    channel::Integer,
    message::Integer,
    emoji::StringOrChar,
    user::Integer,
)

Delete a User's reaction to a Message.

delete_webhook(c::Client, webhook::Integer)

Delete a Webhook.

delete_webhook_with_token(c::Client, webhook::Integer, token::AbstractString)

Delete a Webhook with a token.

disable_cache!(c::Client)
disable_cache!(f::Function, c::Client)

Disable the cache. do syntax is also accepted.

edit_channel_permissions(
    c::Client,
    channel::Integer,
    overwrite::Integer;
    kwargs...,
)

Edit permissions for a DiscordChannel. More details here.

edit_interaction(c::Client, int_id::Snowflake, int_token::String; kwargs...)

Edit a followup message for an interaction.

edit_message(c::Client, channel::Integer, message::Integer; kwargs...) -> Message

Edit a Message. More details here.

enable_cache!(c::Client)
enable_cache!(f::Function c::Client)

Enable the cache. do syntax is also accepted.

execute_github_compatible_webhook(
    c::Client,
    webhook::Integer,
    token::AbstractString;
    wait::Bool=true,
    kwargs...,
)

Execute a Github Webhook. More details here.

execute_slack_compatible_webhook(
    c::Client,
    webhook::Integer,
    token::AbstractString;
    wait::Bool=true,
    kwargs...,
)

Execute a Slack Webhook. More details here.

execute_webhook(
    c::Client,
    webhook::Integer,
    token::AbstractString;
    wait::Bool=false,
    kwargs...,
) -> Message

Execute a Webhook. If wait is not set, no Message is returned. More details here.

Return an empty Dict if the list of options used is missing.

extops(ops::Vector)

Creates a Dict of option name -> option value for the given vector of ApplicationCommandOption. If the option is of Subcommand type, creates a dict for all its subcommands.

fetchval(f::Future{Response{T}}) -> Nullable{T}

Shortcut for fetch(f).val: Fetch a Response and return its value. Note that there are no guarantees about the response's success and the value being returned, and it discards context that can be useful for debugging, such as HTTP responses and caught exceptions.

filter_ranges(u::Vector{UnitRange{Int}})

Filter a list of ranges, discarding ranges included in other ranges from the list.

Example

julia> Ekztazy.filter_ranges([1:5, 3:8, 1:20, 2:16, 10:70, 25:60, 5:35, 50:90, 10:70])
4-element Vector{UnitRange{Int64}}:
 1:20
 5:35
 50:90
 10:70

get_application_commands(c::Client, guild::Snowflake) -> Vector{ApplicationCommand}

Gets all guild ApplicationCommands for the logged in client.

get_application_commands(c::Client) -> Vector{ApplicationCommand}

Gets all global ApplicationCommands for the logged in client.

get_channel(c::Client, channel::Integer) -> DiscordChannel

Get a DiscordChannel.

get_channel_invites(c::Client, channel::Integer) -> Vector{Invite}

Get the Invites for a DiscordChannel.

get_channel_message(c::Client, channel::Integer, message::Integer) -> Message

Get a Message from a DiscordChannel.

get_channel_messages(c::Client, channel::Integer; kwargs...) -> Vector{Message}

Get a list of Messages from a DiscordChannel. More details here.

get_channel_webhooks(c::Client, channel::Integer) -> Vector{Webhook}

Get a list of Webhooks in a DiscordChannel.

get_current_user(c::Client) -> User

Get the Client User.

get_user_guilds(c::Client; kwargs...) -> Vector{Guild}

Get a list of Guilds the Client User is a member of. More details here.

get_guild(c::Client, guild::Integer) -> Guild

Get a Guild.

get_guild_audit_log(c::Client, guild::Integer; kwargs...) -> AuditLog

Get a Guild's AuditLog. More details here.

get_ban(c::Client, guild::Integer,  user::Integer) -> Ban

Get a Ban in a Guild.

get_guild_bans(c::Client, guild::Integer) -> Vector{Ban}

Get a list of Bans in a Guild.

get_guild_channels(c::Client, guild::Integer) -> Vector{DiscordChannel}

Get the DiscordChannels in a Guild.

get_guild_embed(c::Client, guild::Integer) -> GuildEmbed

Get a Guild's GuildEmbed.

get_guild_emoji(c::Client, guild::Integer, emoji::Integer) -> Emoji

Get an Emoji in a Guild.

get_guild_integrations(c::Client, guild::Integer) -> Vector{Integration}

Get a list of Integrations for a Guild.

get_guild_invites(c::Client, guild::Integer) -> Vector{Invite}

Get a list of Invites to a Guild.

get_guild_member(c::Client, guild::Integer, user::Integer) -> Member

Get a Member in a Guild.

get_guild_prune_count(c::Client, guild::Integer; kwargs...) -> Dict

Get the number of Members that would be removed from a Guild in a prune. More details here.

get_guild_roles(c::Client, guild::Integer) -> Vector{Role}

Get a Guild's Roles.

get_guild_voice_regions(c::Client, guild::Integer) -> Vector{VoiceRegion}

Get a list of VoiceRegions for the Guild.

get_guild_webhooks(c::Client, guild::Integer) -> Vector{Webhook}

Get a list of Webhooks in a Guild.

get_guild_widget_image(c::Client, guild::Integer; kwargs...) -> Vector{UInt8}

Get a Guild's widget image in PNG format. More details here.

get_invite(c::Client, invite::AbstractString; kwargs...} -> Invite

Get an Invite to a Guild. More details here.

get_pinned_messages(c::Client, channel::Integer) -> Vector{Message}

Get the pinned Messages in a DiscordChannel.

get_reactions(
    c::Client,
    channel::Integer,
    message::Integer,
    emoji::StringOrChar,
) -> Vector{User}

Get the Users who reacted to a Message with an Emoji.

get_user(c::Client, user::Integer) -> User

Get a User.

get_vanity_url(c::Client, guild::Integer) -> Invite

Get a Guild's vanity URL, if it supports that feature.

get_webhook(c::Client, webhook::Integer) -> Webhook

Get a Webhook.

get_webhook_with_token(c::Client, webhook::Integer, token::AbstractString) -> Webhook

Get a Webhook with a token.

Calls handle with a list of all found handlers.

handle(
    c::Client
    handlers,
    data
)

Determines whether handlers are appropriate to call and calls them if so. Creates an AbstractContext based on the event using the data provided and passes it to the handler.

has_permission(perms::Integer, perm::Permission) -> Bool

Determine whether a bitwise OR of permissions contains one Permission.

Examples

julia> has_permission(0x0420, PERM_VIEW_CHANNEL)
true

julia> has_permission(0x0420, PERM_ADMINISTRATOR)
false

julia> has_permission(0x0008, PERM_MANAGE_ROLES)
true

heartbeat_ping(c::Client) -> Nullable{Period}

Get the Client's ping time to the gateway. If the client is not connected, or no heartbeats have been sent/acknowledged, nothing is returned.

isme(c::Client, ctx::Context) -> Bool

Returns whether the context is a Message Context sent by the bot user.

leave_guild(c::Client, guild::Integer)

Leave a Guild.

list_guild_emojis(c::Client, guild::Integer) -> Vector{Emoji}

Get the Emojis in a Guild.

list_guild_members(c::Client, guild::Integer; kwargs...) -> Vector{Member}

Get a list of Members in a Guild. More details here.

list_voice_regions(c::Client) -> Vector{VoiceRegion}

Get a list of the VoiceRegions that can be used when creating Guilds.

me(c::Client) -> Nullable{User}

Get the Client's bot user.

mention(
    o::DiscordObject
)

Generates the plaintext mention for a User, a Member, a DiscordChannel, a Role, or a Context

method_args(m::Method) -> Vector{Tuple{Symbol, Type}}

modify_channel(c::Client, channel::Integer; kwargs...) -> DiscordChannel

Modify a DiscordChannel. More details here.

modify_current_user(c::Client; kwargs...) -> User

Modify the Client User. More details here.

modify_current_user_nick(c::Client, guild::Intger; kwargs...) -> String

Modify the Client user's nickname in a Guild. More details here.

modify_guild(c::Client, guild::Integer; kwargs...) -> Guild

Edit a Guild. More details here.

modify_guild_channel_positions(c::Client, guild::Integer, positions...)

Modify the positions of DiscordChannels in a Guild. More details here.

modify_guild_embed(c::Client, guild::Integer; kwargs...) -> GuildEmbed

Modify a Guild's GuildEmbed. More details here.

modify_guild_emoji(c::Client, guild::Integer, emoji::Integer; kwargs...) -> Emoji

Edit an Emoji in a Guild. More details here.

modify_guild_integration(c::Client, guild::Integer, integration::Integer; kwargs...)

Modify an Integration in a Guild. More details here.

modify_guild__member(c::Client, guild::Integer, user::Integer; kwargs...)

Modify a Member in a Guild. More details here.

modify_guild_role(c::Client, guild::Integer, role::Integer; kwargs) -> Role

Modify a Role in a Guild. More details here.

modify_guild_role_positions(c::Client, guild::Integer, positions...) -> Vector{Role}

Modify the positions of Roles in a Guild. More details here.

modify_webhook(c::Client, webhook::Integer; kwargs...) -> Webhook

Modify a Webhook. More details here.

modify_webhook_with_token(
    c::Client,
    webhook::Integer,
    token::AbstractString;
    kwargs...,
) -> Webhook

Modify a Webhook with a token. More details here.

obtain(c::Client, ::Type{T}, args...; kwargs...) -> T

Equivalent to retrieve, but blocks and returns the object of type T

on_channel_create!(
    f::Function
    c::Client
)

Adds a handler for the CHANNEL_CREATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_channel_delete!(
    f::Function
    c::Client
)

Adds a handler for the CHANNEL_DELETE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_channel_pins_update!(
    f::Function
    c::Client
)

Adds a handler for the CHANNEL_PINS_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_channel_update!(
    f::Function
    c::Client
)

Adds a handler for the CHANNEL_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_ban_add!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_BAN_ADD gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_ban_remove!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_BAN_REMOVE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_create!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_CREATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_delete!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_DELETE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_emojis_update!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_EMOJIS_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_integrations_update!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_INTEGRATIONS_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_member_add!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_MEMBER_ADD gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_member_remove!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_MEMBER_REMOVE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_member_update!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_MEMBER_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_members_chunk!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_MEMBERS_CHUNK gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_role_create!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_ROLE_CREATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_role_delete!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_ROLE_DELETE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_role_update!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_ROLE_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_guild_update!(
    f::Function
    c::Client
)

Adds a handler for the GUILD_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_interaction_create!(
    f::Function
    c::Client
)

Adds a handler for the INTERACTION_CREATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_create!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_CREATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_delete!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_DELETE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_delete_bulk!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_DELETE_BULK gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_reaction_add!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_REACTION_ADD gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_reaction_remove!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_REACTION_REMOVE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_reaction_remove_all!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_REACTION_REMOVE_ALL gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_message_update!(
    f::Function
    c::Client
)

Adds a handler for the MESSAGE_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_presence_update!(
    f::Function
    c::Client
)

Adds a handler for the PRESENCE_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_ready!(
    f::Function
    c::Client
)

Adds a handler for the READY gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_resumed!(
    f::Function
    c::Client
)

Adds a handler for the RESUMED gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_typing_start!(
    f::Function
    c::Client
)

Adds a handler for the TYPING_START gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_user_update!(
    f::Function
    c::Client
)

Adds a handler for the USER_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_voice_server_update!(
    f::Function
    c::Client
)

Adds a handler for the VOICE_SERVER_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_voice_state_update!(
    f::Function
    c::Client
)

Adds a handler for the VOICE_STATE_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

on_webhooks_update!(
    f::Function
    c::Client
)

Adds a handler for the WEBHOOKS_UPDATE gateway event. The f parameter's signature should be:

    (ctx::Context) -> Any 

opt(ctx::Context)

Helper function that is equivalent to calling extops(ctx.interaction.data.options)

Deprecated, use Option instead

permissions_in(m::Member, g::Guild, ch::DiscordChannel) -> Int64

Compute a Member's Permissions in a DiscordChannel.

plaintext(m::Message) -> String
plaintext(c::Client, m::Message) -> String

Get the Message contents with any User mentions replaced with their plaintext. If a Client is provided, DiscordChannels Role are also replaced. However, only channels and roles stored in state are replaced; no API requests are made.

remove_guild_ban(c::Client, guild::Integer, user::Integer)

Unban a User from a Guild.

remove_guild_member(c::Client, guild::Integer, user::Integer)

Kick a Member from a Guild.

remove_guild_member_role(c::Client, guild::Integer, user::Integer, role::Integer)

Remove a Role from a Member.

reply(
    c::Client
    context;
    kwargs...
)

Replies to a Context, an Interaction or a Message.

request_guild_members(
    c::Client,
    guilds::Union{Integer, Vector{<:Integer};
    query::AbstractString="",
    limit::Int=0,
) -> Bool

Request offline guild members of one or more Guilds. on_guild_members_chunk! events are sent by the gateway in response. More details here.

respond_to_interaction(c::Client, int_id::Snowflake, int_token::String; kwargs...) -> Message

Respond to an interaction with code 4.

retrieve(c::Client, ::Type{T}, args...; kwargs...) -> Future{Response{T}}

Retrieve, get, list, etc.

Examples

Getting the Client's User:

retrieve(c, User)

Getting a Guild's DiscordChannels:

retrieve(c, DiscordChannel, guild)

Getting an Invite to a Guild by code:

retrieve(c, Invite, "abcdef")

Runs a handler with given context

select!(
    f::Function
    c::Client
    custom_id::AbstractString
    args::Vector{Tuple}
    kwargs...
)

Adds a handler for INTERACTION CREATE gateway events where the InteractionData's custom_id field matches custom_id. The f parameter signature should be:

(ctx::Context, choices::Vector{String}) -> Any 

set_game(
    c::Client,
    game::AbstractString;
    type::Int=AT.GAME,
    since::Nullable{Int}=c.presence["since"],
    status::Union{PresenceStatus, AbstractString}=c.presence["status"],
    afk::Bool=c.presence["afk"],
    kwargs...,
) -> Bool

Shortcut for update_status to set the Client's Activity. Any additional keywords are passed into the activity section.

split_message(text::AbstractString; chunk_limit::UInt=2000,
              extrastyles::Vector{Regex}=Vector{Regex}(),
              forcesplit::Bool = true) -> Vector{String}

Split a message into chunks with at most chunk_limit length, preserving formatting.

The chunk_limit has as default the 2000 character limit of Discord's messages, but can be changed to any nonnegative integer.

Formatting is specified by STYLES) and can be aggregated with the extrastyles argument.

Discord limits messages to 2000, so the code forces split if format breaking cannot be avoided. If desired, however, this behavior can be lifter by setting forcesplit to false.

Examples

julia> split_message("foo")
1-element Vector{String}:
 "foo"

julia> split_message(repeat('.', 1995) * "**hello, world**")[2]
"**hello, world**"

julia> split_message("**hello**, *world*", chunk_limit=10)
2-element Vector{String}:
 "**hello**,"
 "*world*"

julia> split_message("**hello**, _*beautiful* world_", chunk_limit=15)
┌ Warning: message was forced-split to fit the desired chunk length limit 15
└ @ Main REPL[66]:28
3-element Vector{String}:
 "**hello**,"
 "_*beautiful* wo"
 "rld_"

julia> split_message("**hello**, _*beautiful* world_", chunk_limit=15, forcesplit=false)
┌ Warning: message could not be split into chunks smaller than the length limit 15
└ @ Main REPL[66]:32
2-element Vector{String}:
 "**hello**,"
 "_*beautiful* world_"

julia> split_message("**hello**\n=====\n", chunk_limit=12)
2-element Vector{String}:
 "**hello**\n=="
 "==="
  
julia> split_message("**hello**\n≡≡≡≡≡\n", chunk_limit=12, extrastyles = [r"\n≡+\n"])
2-element Vector{String}:
 "**hello**"
 "≡≡≡≡≡"

start(c::Client)

Creates a handler to generate ApplicationCommands.

Creates handlers for GuildCreate events.

Calls open then wait on the Client.

sync_guild_integration(c::Client, guild::Integer, integration::Integer)

Sync an Integration in a Guild.

trigger_typing_indicator(c::Client, channel::Integer)

Trigger the typing indicator in a DiscordChannel.

update(c::Client, x::T, args...; kwargs...) -> Future{Response}

Update, edit, modify, etc.

Examples

Editing a Message:

update(c, message; content="foo2")

Modifying a Webhook:

update(c, webhook; name="bar2")

Updating a Role:

update(c, role, guild; permissions=8)

update_ack_interaction(c::Client, int_id::Snowflake, int_token::String; kwargs...) -> Message

Respond to an interaction with code 6.

update_message_int(c::Client, int_id::Snowflake, int_token::String; kwargs...)

Respond to an interaction with code 7.

update_status(
    c::Client,
    since::Nullable{Int},
    activity::Nullable{Activity},
    status::Union{PresenceStatus, AbstractString},
    afk::Bool,
) -> Bool

Indicate a presence or status update. A PresenceUpdate event is sent by the gateway in response. More details here.

update_voice_state(
    c::Client,
    guild::Integer,
    channel::Nullable{Integer},
    mute::Bool,
    deaf::Bool,
) -> Bool

Join, move, or disconnect from a voice channel. A VoiceStateUpdate event is sent by the gateway in response. More details here.

upload_file(c::Client, ch::DiscordChannel, path::AbstractString; kwargs...) -> Message

Send a Message with a file Attachment. Any keywords are passed on to create_message.

@deferred_fetch [functions...] block

Identical to @fetch, but Futures are not fetched until the end of the block. This is more efficient, but only works when there are no data dependencies in the block.

Examples

This will work:

@deferred_fetch begin
    guild_resp = create(c, Guild; name="foo")
    channel_resp = retrieve(c, DiscordChannel, 123)
end

This will not, because the second call is dependent on the first value:

@deferred_fetch begin
    guild_resp = create(c, Guild; name="foo")
    channels_resp = retrieve(c, DiscordChannel, guild_resp.val)
end

@deferred_fetchval [functions...] block

Identical to @deferred_fetch, but Futures have fetchval called on them instead of fetch.

@fetch [functions...] block

Wrap all calls to the specified CRUD functions (create, retrieve, update, and delete) with fetch inside a block. If no functions are specified, all CRUD functions are wrapped.

Examples

Wrapping all CRUD functions:

@fetch begin
    guild_resp = create(c, Guild; name="foo")
    guild_resp.ok || error("Request for new guild failed")
    channel_resp = retrieve(c, DiscordChannel, guild_resp.val)
end

Wrapping only calls to retrieve:

@fetch retrieve begin
    resp = retrieve(c, DiscordChannel, 123)
    future = create(c, Message, resp.val; content="foo")  # Behaves normally.
end

@fetchval [functions...] block

Identical to @fetch, but calls are wrapped with fetchval instead.