discord #

fn bearer(token string, config RESTConfig) REST

bearer accepts access token and returns REST that can be used to make requests

Note: token should not contain Bearer prefix

fn bot(token string, config BotConfig) GatewayClient

bot creates a new [GatewayClient] that can be used to listen events. Use launch to connect to gateway.

Note: token should not contain Bot prefix

fn build_multipart_with_files(files []File, j json2.Any) (string, string)

fn bulk_delete_in_map[K, V](mut m map[K]V, a []K)

fn cache_add1[T](mut m1 map[Snowflake]T, max_size ?int, check fn (id1 Snowflake, o T) bool, id1 Snowflake, o T)

fn cache_add2[T](mut m1 map[Snowflake]map[Snowflake]T, max_size1 ?int, max_size2 ?int, check fn (id1 Snowflake, id2 Snowflake, o T) bool, id1 Snowflake, id2 Snowflake, o T)

fn compute_permissions(member GuildMember, channel Channel, guild Guild) Permissions

Overwrites can be used to apply certain permissions to roles or members on a channel-level. Applicable permissions are indicated by a T for text channels, V for voice channels, or S for stage channels in the table above. When using overwrites, there are cases where permission collisions could occur for a user; that is to say, the user may have certain overwrites with permissions that contradict each other or their guild-level role permissions. With this in mind, permissions are applied to users in the following hierarchy:1. Base permissions given to @everyone are applied at a guild level2. Permissions allowed to a user by their roles are applied at a guild level3. Overwrites that deny permissions for @everyone are applied at a channel level4. Overwrites that allow permissions for @everyone are applied at a channel level5. Overwrites that deny permissions for specific roles are applied at a channel level6. Overwrites that allow permissions for specific roles are applied at a channel level7. Member-specific overwrites that deny permissions are applied at a channel level8. Member-specific overwrites that allow permissions are applied at a channel levelMore at https://discord.com/developers/docs/topics/permissions#permission-overwrites...

fn extract_id_from_token(token string) !Snowflake

fn format_iso8601(t time.Time) string

2015-04-26T06:26:56.936000+00:00

fn is_sentinel[T](target T) bool

is_sentinel reports whether target is sentinel

fn maybe_map[T, X](a []T, f fn (T) !X) ![]X

fn maybe_map_map[T, U, X, Y](m map[T]U, f fn (T, U) !(X, Y)) !map[X]Y

fn milliseconds_as_time(ts i64) time.Time

fn multipart_form_body(files map[string][]http.FileData) (string, string)

fn new_cdn(params NewCDNParams) CDN

fn new_rest(token string, config RESTConfig) REST

fn new_rpc(file io.ReaderWriter) !RPC

fn null[T]() NullOr[T]

we are not going to support JavaScript

fn oauth2_app(client_id Snowflake, client_secret string, config RESTConfig) REST

oauth2_app accepts client ID and secret and returns REST with Basic token

fn some[T](val T) NullOr[T]

fn verify_request(public_key ed25519.PublicKey, req http.Request) bool

fn Action.parse(j json2.Any) !Action

fn ActionMetadata.parse(j json2.Any) !ActionMetadata

fn ActionRow.internal_parse(j map[string]json2.Any) !ActionRow

fn ActionRow.parse(j json2.Any) !ActionRow

fn Activity.parse(j json2.Any) !Activity

fn ActivityAssets.parse(j json2.Any) !ActivityAssets

fn ActivityButton.parse(j json2.Any) !ActivityButton

fn ActivityEmoji.parse(j json2.Any) !ActivityEmoji

fn ActivityParty.parse(j json2.Any) !ActivityParty

fn ActivitySecrets.parse(j json2.Any) !ActivitySecrets

fn ActivityTimestamps.parse(j json2.Any) !ActivityTimestamps

fn Application.parse(j json2.Any) !Application

fn ApplicationCommand.parse(j json2.Any) !ApplicationCommand

fn ApplicationCommandData.parse(j json2.Any) !ApplicationCommandData

fn ApplicationCommandInteractionDataOption.parse(j json2.Any) !ApplicationCommandInteractionDataOption

fn ApplicationCommandInteractionDataOptionValue.parse(j json2.Any) !ApplicationCommandInteractionDataOptionValue

fn ApplicationCommandOption.parse(j json2.Any) !ApplicationCommandOption

fn ApplicationCommandOptionChoice.parse(j json2.Any) !ApplicationCommandOptionChoice

fn ApplicationCommandPermission.parse(j json2.Any) !ApplicationCommandPermission

fn ApplicationCommandPermissionsUpdateEvent.parse(j json2.Any, base BaseEvent) !ApplicationCommandPermissionsUpdateEvent

fn ApplicationRoleConnection.parse(j json2.Any) !ApplicationRoleConnection

fn ApplicationRoleConnectionMetadata.parse(j json2.Any) !ApplicationRoleConnectionMetadata

fn Attachment.parse(j json2.Any) !Attachment

fn AuditEntryInfo.parse(j json2.Any) !AuditEntryInfo

fn AuditLog.parse(j json2.Any) !AuditLog

fn AuditLogChange.parse(j json2.Any) !AuditLogChange

fn AuditLogEntry.parse(j json2.Any) !AuditLogEntry

fn AutoModerationActionExecutionEvent.parse(j json2.Any, base BaseEvent) !AutoModerationActionExecutionEvent

fn AutoModerationRule.parse(j json2.Any) !AutoModerationRule

fn AutoModerationRuleCreateEvent.parse(j json2.Any, base BaseEvent) !AutoModerationRuleCreateEvent

fn AutoModerationRuleDeleteEvent.parse(j json2.Any, base BaseEvent) !AutoModerationRuleDeleteEvent

fn AutoModerationRuleUpdateEvent.parse(j json2.Any, base BaseEvent) !AutoModerationRuleUpdateEvent

fn AvatarDecorationData.parse(j json2.Any) !AvatarDecorationData

fn Ban.parse(j json2.Any) !Ban

fn BulkBanResponse.parse(j json2.Any) !BulkBanResponse

fn Button.internal_parse(j map[string]json2.Any) !Button

fn Button.parse(j json2.Any) !Button

fn CDNAttachment.parse(url string) !CDNAttachment

fn Channel.parse(j json2.Any) !Channel

fn ChannelCreateEvent.parse(j json2.Any, base BaseEvent) !ChannelCreateEvent

fn ChannelDeleteEvent.parse(j json2.Any, base BaseEvent) !ChannelDeleteEvent

fn ChannelMention.parse(j json2.Any) !ChannelMention

fn ChannelPinsUpdateEvent.parse(j json2.Any, base BaseEvent) !ChannelPinsUpdateEvent

fn ChannelSelect.internal_parse(j map[string]json2.Any) !ChannelSelect

fn ChannelSelect.parse(j json2.Any) !ChannelSelect

fn ChannelUpdateEvent.parse(j json2.Any, base BaseEvent) !ChannelUpdateEvent

fn ClientStatus.parse(j json2.Any) !ClientStatus

fn Component.parse(j json2.Any) !Component

fn ComponentEmoji.parse(j json2.Any) !ComponentEmoji

fn Connection.parse(j json2.Any) !Connection

fn DefaultReaction.parse(j json2.Any) !DefaultReaction

fn DefaultValue.parse(j json2.Any) !DefaultValue

fn Embed.parse(j json2.Any) !Embed

fn EmbedAuthor.parse(j json2.Any) !EmbedAuthor

fn EmbedField.parse(j json2.Any) !EmbedField

fn EmbedFooter.parse(j json2.Any) !EmbedFooter

fn EmbedImage.parse(j json2.Any) !EmbedImage

fn EmbedProvider.parse(j json2.Any) !EmbedProvider

fn EmbedThumbnail.parse(j json2.Any) !EmbedThumbnail

fn EmbedVideo.parse(j json2.Any) !EmbedVideo

fn Emoji.parse(j json2.Any) !Emoji

fn Entitlement.parse(j json2.Any) !Entitlement

fn EntitlementCreateEvent.parse(j json2.Any, base BaseEvent) !EntitlementCreateEvent

fn EntitlementDeleteEvent.parse(j json2.Any, base BaseEvent) !EntitlementDeleteEvent

fn EntitlementUpdateEvent.parse(j json2.Any, base BaseEvent) !EntitlementUpdateEvent

fn FollowedChannel.parse(j json2.Any) !FollowedChannel

fn ForumTag.parse(j json2.Any) !ForumTag

fn GatewayConfiguration.parse(j json2.Any) !GatewayConfiguration

fn GatewayIntents.all() GatewayIntents

fn GatewayIntents.all_privileged() GatewayIntents

fn GatewayIntents.all_unprivileged() GatewayIntents

fn Guild.internal_parse(j map[string]json2.Any) !Guild

fn Guild.parse(j json2.Any) !Guild

fn Guild2.internal_parse(j map[string]json2.Any) !Guild2

fn Guild2.parse(j json2.Any) !Guild2

fn GuildApplicationCommandPermissions.parse(j json2.Any) !GuildApplicationCommandPermissions

fn GuildAuditLogEntryCreateEvent.parse(j json2.Any, base BaseEvent) !GuildAuditLogEntryCreateEvent

fn GuildBanAddEvent.parse(j json2.Any, base BaseEvent) !GuildBanAddEvent

fn GuildBanRemoveEvent.parse(j json2.Any, base BaseEvent) !GuildBanRemoveEvent

fn GuildCreateEvent.parse(j json2.Any, base BaseEvent) !GuildCreateEvent

fn GuildDeleteEvent.parse(j json2.Any, base BaseEvent) !GuildDeleteEvent

fn GuildEmojisUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildEmojisUpdateEvent

fn GuildIntegrationsUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildIntegrationsUpdateEvent

fn GuildMember.parse(j json2.Any) !GuildMember

fn GuildMember2.parse(j json2.Any) !GuildMember2

fn GuildMemberAddEvent.parse(j json2.Any, base BaseEvent) !GuildMemberAddEvent

fn GuildMemberRemoveEvent.parse(j json2.Any, base BaseEvent) !GuildMemberRemoveEvent

fn GuildMemberUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildMemberUpdateEvent

fn GuildMembersChunkEvent.parse(j json2.Any, base BaseEvent) !GuildMembersChunkEvent

fn GuildOnboarding.parse(j json2.Any) !GuildOnboarding

fn GuildPreview.parse(j json2.Any) !GuildPreview

fn GuildRoleCreateEvent.parse(j json2.Any, base BaseEvent) !GuildRoleCreateEvent

fn GuildRoleDeleteEvent.parse(j json2.Any, base BaseEvent) !GuildRoleDeleteEvent

fn GuildRoleUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildRoleUpdateEvent

fn GuildScheduledEvent.parse(j json2.Any) !GuildScheduledEvent

fn GuildScheduledEventCreateEvent.parse(j json2.Any, base BaseEvent) !GuildScheduledEventCreateEvent

fn GuildScheduledEventDeleteEvent.parse(j json2.Any, base BaseEvent) !GuildScheduledEventDeleteEvent

fn GuildScheduledEventEntityMetadata.parse(j json2.Any) !GuildScheduledEventEntityMetadata

fn GuildScheduledEventUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildScheduledEventUpdateEvent

fn GuildScheduledEventUser.parse(j json2.Any) !GuildScheduledEventUser

fn GuildScheduledEventUserAddEvent.parse(j json2.Any, base BaseEvent) !GuildScheduledEventUserAddEvent

fn GuildScheduledEventUserRemoveEvent.parse(j json2.Any, base BaseEvent) !GuildScheduledEventUserRemoveEvent

fn GuildStickersUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildStickersUpdateEvent

fn GuildTemplate.parse(j json2.Any) !GuildTemplate

fn GuildUpdateEvent.parse(j json2.Any, base BaseEvent) !GuildUpdateEvent

fn GuildVanityUrl.parse(j json2.Any) !GuildVanityUrl

fn GuildWidget.parse(j json2.Any) !GuildWidget

fn GuildWidgetSettings.parse(j json2.Any) !GuildWidgetSettings

fn InstallParams.parse(j json2.Any) !InstallParams

fn Integration.parse(j json2.Any) !Integration

fn Integration2.parse(j json2.Any) !Integration2

fn IntegrationAccount.parse(j json2.Any) !IntegrationAccount

fn IntegrationApplication.parse(j json2.Any) !IntegrationApplication

fn IntegrationCreateEvent.parse(j json2.Any, base BaseEvent) !IntegrationCreateEvent

fn IntegrationDeleteEvent.parse(j json2.Any, base BaseEvent) !IntegrationDeleteEvent

fn IntegrationUpdateEvent.parse(j json2.Any, base BaseEvent) !IntegrationUpdateEvent

fn Interaction.parse(j json2.Any) !Interaction

fn InteractionCreateEvent.parse(j json2.Any, base BaseEvent) !InteractionCreateEvent

fn Invite.parse(j json2.Any) !Invite

fn InviteCreateEvent.parse(j json2.Any, base BaseEvent) !InviteCreateEvent

fn InviteDeleteEvent.parse(j json2.Any, base BaseEvent) !InviteDeleteEvent

fn InviteMetadata.parse(j json2.Any) !InviteMetadata

fn ListThreadsResponse.parse(j json2.Any) !ListThreadsResponse

fn MentionableSelect.internal_parse(j map[string]json2.Any) !MentionableSelect

fn MentionableSelect.parse(j json2.Any) !MentionableSelect

fn Message.parse(j json2.Any) !Message

fn Message2.parse(j json2.Any) !Message2

fn MessageActivity.parse(j json2.Any) !MessageActivity

fn MessageComponentData.parse(j json2.Any) !MessageComponentData

fn MessageCreateEvent.parse(j json2.Any, base BaseEvent) !MessageCreateEvent

fn MessageDeleteBulkEvent.parse(j json2.Any, base BaseEvent) !MessageDeleteBulkEvent

fn MessageDeleteEvent.parse(j json2.Any, base BaseEvent) !MessageDeleteEvent

fn MessageInteraction.parse(j json2.Any) !MessageInteraction

fn MessageReactionAddEvent.parse(j json2.Any, base BaseEvent) !MessageReactionAddEvent

fn MessageReactionRemoveAllEvent.parse(j json2.Any, base BaseEvent) !MessageReactionRemoveAllEvent

fn MessageReactionRemoveEmojiEvent.parse(j json2.Any, base BaseEvent) !MessageReactionRemoveEmojiEvent

fn MessageReactionRemoveEvent.parse(j json2.Any, base BaseEvent) !MessageReactionRemoveEvent

fn MessageReference.parse(j json2.Any) !MessageReference

fn MessageUpdateEvent.parse(j json2.Any, base BaseEvent) !MessageUpdateEvent

fn ModalSubmitData.parse(j json2.Any) !ModalSubmitData

fn Number.parse(j json2.Any) !Number

fn OnboardingPrompt.parse(j json2.Any) !OnboardingPrompt

fn PartialApplication.parse(j json2.Any) !PartialApplication

fn PartialChannel.parse(j json2.Any) !PartialChannel

fn PartialEmoji.parse(j json2.Any) !PartialEmoji

fn PartialGuild.parse(j json2.Any) !PartialGuild

fn PartialGuildMember.parse(j json2.Any) !PartialGuildMember

fn PartialIntegration.parse(j json2.Any) !PartialIntegration

fn PartialMessage.parse(j json2.Any) !PartialMessage

fn PartialUser.parse(j json2.Any) !PartialUser

fn PermissionOverwrite.parse(j json2.Any) !PermissionOverwrite

fn Permissions.all() Permissions

fn Permissions.all_except(permissions Permissions) Permissions

fn Permissions.parse(j json2.Any) !Permissions

fn Presence.parse(j json2.Any) !Presence

fn PresenceUpdateEvent.parse(j json2.Any, base BaseEvent) !PresenceUpdateEvent

fn PromptOption.parse(j json2.Any) !PromptOption

fn REST.delete_webhook_with_token(webhook_id Snowflake, webhook_token string, params ReasonParam) !

Same as above, except this call does not require authentication.

fn REST.do_request(rest &REST, method http.Method, route string, options RequestOptions) !http.Response

fn REST.edit_webhook_with_token(webhook_id Snowflake, webhook_token string, params EditWebhookParams) !Webhook

Same as above, except this call does not require authentication, does not accept a channel_id parameter in the body, and does not return a user in the webhook object.

fn REST.execute_webhook(webhook_id Snowflake, webhook_token string, params ExecuteWebhookParams) !&Message

Returns a message or 204 No Content depending on the wait query parameter. > i Note that when sending a message, you must provide a value for at least one of content, embeds, components, or files. > i If the webhook channel is a forum or media channel, you must provide either thread_id in the query string params, or thread_name in the JSON/form params. If thread_id is provided, the message will send in that thread. If thread_name is provided, a thread with that name will be created in the channel. > ! Discord may strip certain characters from message content, like invalid unicode characters or characters which cause unexpected message formatting. If you are passing user-generated strings into message content, consider sanitizing the data to prevent unexpected behavior and using allowed_mentions to prevent unexpected mentions. pub fn (rest &REST) execute_webhook(webhook_id Snowflake, webhook_token string, params ExecuteWebhookParams) !&Message {

fn Reaction.parse(j json2.Any) !Reaction

fn ReactionCountDetails.parse(j json2.Any) !ReactionCountDetails

fn ReadyEvent.parse(j json2.Any, base BaseEvent) !ReadyEvent

fn Resolved.parse(j json2.Any) !Resolved

fn ResumedEvent.parse(j json2.Any, base BaseEvent) !ResumedEvent

fn Role.parse(j json2.Any) !Role

fn RoleSelect.internal_parse(j map[string]json2.Any) !RoleSelect

fn RoleSelect.parse(j json2.Any) !RoleSelect

fn RoleSubscriptionData.parse(j json2.Any) !RoleSubscriptionData

fn RoleTags.parse(j json2.Any) !RoleTags

fn SelectOption.parse(j json2.Any) !SelectOption

fn SessionStartLimit.parse(j json2.Any) !SessionStartLimit

fn Sku.parse(j json2.Any) !Sku

fn Snowflake.from(t time.Time) Snowflake

fn Snowflake.now() Snowflake

fn Snowflake.parse(j json2.Any) !Snowflake

fn StageInstance.parse(j json2.Any) !StageInstance

fn StageInstanceCreateEvent.parse(j json2.Any, base BaseEvent) !StageInstanceCreateEvent

fn StageInstanceDeleteEvent.parse(j json2.Any, base BaseEvent) !StageInstanceDeleteEvent

fn StageInstanceUpdateEvent.parse(j json2.Any, base BaseEvent) !StageInstanceUpdateEvent

fn Status.parse(j json2.Any) !Status

fn Sticker.parse(j json2.Any) !Sticker

fn StickerItem.parse(j json2.Any) !StickerItem

fn StickerPack.parse(j json2.Any) !StickerPack

fn StringSelect.internal_parse(j map[string]json2.Any) !StringSelect

fn StringSelect.parse(j json2.Any) !StringSelect

fn Team.parse(j json2.Any) !Team

fn TeamMember.parse(j json2.Any) !TeamMember

fn TextInput.internal_parse(j map[string]json2.Any) !TextInput

fn TextInput.parse(j json2.Any) !TextInput

fn ThreadCreateEvent.parse(j json2.Any, base BaseEvent) !ThreadCreateEvent

fn ThreadDeleteEvent.parse(j json2.Any, base BaseEvent) !ThreadDeleteEvent

fn ThreadListSyncEvent.parse(j json2.Any, base BaseEvent) !ThreadListSyncEvent

fn ThreadMember.parse(j json2.Any) !ThreadMember

fn ThreadMember2.parse(j json2.Any) !ThreadMember2

fn ThreadMemberUpdateEvent.parse(j json2.Any, base BaseEvent) !ThreadMemberUpdateEvent

fn ThreadMetadata.parse(j json2.Any) !ThreadMetadata

fn ThreadUpdateEvent.parse(j json2.Any, base BaseEvent) !ThreadUpdateEvent

fn TriggerMetadata.parse(j json2.Any) !TriggerMetadata

fn TypingStartEvent.parse(j json2.Any, base BaseEvent) !TypingStartEvent

fn UnavailableGuild.parse(j json2.Any) !UnavailableGuild

fn User.parse(j json2.Any) !User

fn UserSelect.internal_parse(j map[string]json2.Any) !UserSelect

fn UserSelect.parse(j json2.Any) !UserSelect

fn UserUpdateEvent.parse(j json2.Any, base BaseEvent) !UserUpdateEvent

fn VoiceRegion.parse(j json2.Any) !VoiceRegion

fn VoiceServerUpdateEvent.parse(j json2.Any, base BaseEvent) !VoiceServerUpdateEvent

fn VoiceState.parse(j json2.Any) !VoiceState

fn VoiceStateUpdateEvent.parse(j json2.Any, base BaseEvent) !VoiceStateUpdateEvent

fn Webhook.parse(j json2.Any) !Webhook

fn WebhooksUpdateEvent.parse(j json2.Any, base BaseEvent) !WebhooksUpdateEvent

fn WelcomeChannel.parse(j json2.Any) !WelcomeChannel

fn WelcomeScreen.parse(j json2.Any) !WelcomeScreen

interface Component {
	is_component()
	build() json2.Any
}

ignore is_component(), it is used to differ interfaces

interface EditChannelParams {
	reason ?string
	is_edit_channel_params()
	build() json2.Any
}

interface HTTPClient {
	is_http_client()
	perform(http.Request) !http.Response
}

interface IInteractionResponse {
	is_interaction_response()
	get_files() ?[]File
	build() json2.Any
}

interface Image {
	data []u8
	is_image()
	content_type() string
	build() string
}

interface InteractionResponseData {
	is_interaction_response_data()
	get_files() ?[]File
	build() json2.Any
}

type ApplicationCommandInteractionDataOptionValue = bool | f64 | int | string

fn (v ApplicationCommandInteractionDataOptionValue) as_string() string

fn (v ApplicationCommandInteractionDataOptionValue) as_int() int

fn (v ApplicationCommandInteractionDataOptionValue) as_f64() f64

fn (v ApplicationCommandInteractionDataOptionValue) as_bool() bool

type ApplicationCommandOptionChoiceValue = f64 | int | string

type ArrayOrSnowflake = Snowflake | []Snowflake

fn (aos ArrayOrSnowflake) build() json2.Any

type Check[T] = fn (T) bool

type ConnectionService = string

fn (mut a EventChannel[T]) close()

Closes an event channel

fn (mut a EventChannel[T]) receive() ?T

receive waits for event and returns it. After it returned event, you should call close() on it to release resources. If timeout is exceeded, it returns none

fn (mut ec EventController[T]) emit(e T, options EmitOptions)

emit broadcasts passed object to all listeners

fn (mut ec EventController[T]) wait(params EventWaitParams[T]) EventChannel[T]

wait returns EventChannel that can be used to receive events > ! Do not use that directly in events, please take a reference using mut controller := &events.creator.events.on_x

fn (mut ec EventController[T]) override(listener EventListener[T]) EventController[T]

override removes all listeners and inserts listener

fn (mut ec EventController[T]) listen(listener EventListener[T]) EventController[T]

listen adds function to listener list

type EventListener[T] = fn (T) !

type GuildFeature = string

type Locale = string

type Nonce = int | string

fn (no NullOr[T]) is_present[T]() bool

fn (no NullOr[T]) value[T]() T

type Number = f64 | int

fn (n Number) build() json2.Any

type Snowflake = u64

fn (s Snowflake) raw_timestamp() u64

fn (s Snowflake) timestamp() time.Time

fn (s Snowflake) build() json2.Any

fn (mut s Snowflake) from_json(f json2.Any)

fn (s Snowflake) str() string

fn (s Snowflake) json_str() string

type TeamMemberRole = string

fn (r []Component) flatten() []Component

fn (cs []Component) find_where(f fn (Component) bool) ?Component

fn (cs []Component) find[T](f fn (T) bool) ?T

enum ActionType {
	// blocks a member's message and prevents it from being posted. A custom explanation can be specified and shown to members whenever their message is blocked.
	block_message      = 1
	// logs user content to a specified channel
	send_alert_message
	// timeout user for a specified duration
	timeout
}

enum ActivityFlags {
	instance
	join
	spectate
	join_request
	sync
	play
	party_privacy_frineds
	party_privacy_voice_channel
	embedded
}

enum ActivityType {
	// Playing {name}: "Playing Rocket League"
	game      = 0
	// Streaming {details}: "Streaming Rocket League"
	streaming
	// Listening to {name}: "Listening to Spotify"
	listening
	// Watching {name}: "Watching YouTube Together"
	watching
	// {emoji} {state}: ":smiley: I am cool"
	custom
	// Competing in {name}: "Competing in Arena World Champions"
	competing
}

enum AllowedMentionType {
	// Controls role mentions
	roles
	// Controls user mentions
	users
	// Controls @everyone and @here mentions
	everyone
}

fn (amt AllowedMentionType) build() string

enum ApplicationCommandOptionType {
	sub_command       = 1
	sub_command_group
	string
	// Any integer between -2^53 and 2^53
	integer
	boolean
	user
	// Includes all channel types + categories
	channel
	role
	// Includes users and roles
	mentionable
	// Any double between -2^53 and 2^53
	number
	attachment
}

pub type LocaleMapping = map[Locale]string

enum ApplicationCommandPermissionType {
	role    = 1
	user
	channel
}

Application Command Permission Type

enum ApplicationCommandType {
	// Slash commands; a text-based command that shows up when a user types `/`
	chat_input = 1
	// A UI-based command that shows up when you right click or tap on a user
	user
	// A UI-based command that shows up when you right click or tap on a message
	message
}

enum ApplicationFlags {
	reserved_0
	reserved_1
	reserved_2
	reserved_3
	reserved_4
	reserved_5
	// Indicates if an app uses the Auto Moderation API
	application_auto_moderation_rule_create_badge
	reserved_7
	reserved_8
	reserved_9
	reserved_10
	reserved_11
	// Intent required for bots in **100 or more servers** to receive `presence_update` events
	gateway_presence
	// Intent required for bots in under 100 to receive `presence_update` events, found on the **Bot** page in your app's settings
	gateway_presence_limited
	// Intent required for bots in **100 or more servers** to receive member-related events like `guild_member_add`. See the list of member-related events under `GUILD_MEMBERS`
	gateway_guild_members
	// Intent required for bots in under 100 servers to receive member-related events like `guild_member_add`, found on the **Bot** page in your app's settings. See the list of member-related events under GUILD_MEMBERS
	gateway_guild_members_limited
	// Indicates unusual growth of an app that prevents verification
	verification_pending_guild_limit
	// Indicates if an app is embedded within the Discord client (currently unavailable publicly)
	embedded
	// Intent required for bots in **100 or more servers** to receive message content
	gateway_message_content
	// Intent required for bots in under 100 servers to receive message content, found on the **Bot** page in your app's settings
	gateway_message_content_limited
	reserved_20
	reserved_21
	reserved_22
	// Indicates if an app has registered global application commands
	application_command_badge
}

enum ApplicationRoleConnectionMetadataType {
	// the metadata value (`integer`) is less than or equal to the guild's configured value (`integer`)
	integer_less_than_or_equal     = 1
	// the metadata value (`integer`) is greater than or equal to the guild's configured value (`integer`)
	integer_greater_than_or_equal
	// the metadata value (`integer`) is equal to the guild's configured value (`integer`)
	integer_equal
	// the metadata value (`integer`) is not equal to the guild's configured value (`integer`)
	integer_not_equal
	// the metadata value (`ISO8601 string`) is less than or equal to the guild's configured value (`integer`; `days before current date`)
	datetime_less_than_or_equal
	// the metadata value (`ISO8601 string`) is greater than or equal to the guild's configured value (`integer`; `days before current date`)
	datetime_greater_than_or_equal
	// the metadata value (`integer`) is equal to the guild's configured value (`integer`; `1`)
	boolean_equal
	// the metadata value (`integer`) is not equal to the guild's configured value (`integer`; `1`)
	boolean_not_equal
}

enum AttachmentFlags {
	reserved_0
	reserved_1
	// this attachment has been edited using the remix feature on mobile
	is_remix
}

enum AuditLogEvent {
	// Server settings were updated
	guild_update                                = 1
	// Channel was created
	channel_create                              = 10
	// Channel settings were updated
	channel_update
	// Channel was deleted
	channel_delete
	// Permission overwrite was added to a channel
	channel_overwrite_create
	// Permission overwrite was updated for a channel
	channel_overwrite_update
	// Permission overwrite was deleted from a channel
	channel_overwrite_delete
	// Member was removed from server
	member_kick                                 = 20
	// Members were pruned from server
	member_prune
	// Member was banned from server
	member_ban_add
	// Server ban was lifted for a member
	member_ban_remove
	// Member was updated in server
	member_update
	// Member was added or removed from a role
	member_role_update
	// Member was moved to a different voice channel
	member_move
	// Member was disconnected from a voice channel
	member_disconnect
	// Bot user was added to server
	bot_add
	// Role was created
	role_create                                 = 30
	// Role was edited
	role_update
	// Role was deleted
	role_delete
	// Server invite was created
	invite_create                               = 40
	// Server invite was updated
	invite_update
	// Server invite was deleted
	invite_delete
	// Webhook was created
	webhook_create
	// Webhook properties or channel were updated
	webhook_update
	// Webhook was deleted
	webhook_delete
	// Emoji was created
	emoji_create
	// Emoji name was updated
	emoji_update
	// Emoji was deleted
	emoji_delete
	// Single message was deleted
	message_delete                              = 72
	// Multiple messages were deleted
	message_bulk_delete
	// Message was pinned to a channel
	message_pin
	// Message was unpinned from a channel
	message_unpin
	// App was added to server
	integration_create                          = 80
	// App was updated (as an example, its scopes were updated)
	integration_update
	// App was removed from server
	integration_delete
	// Stage instance was created (stage channel becomes live)
	stage_instance_create
	// Stage instance details were updated
	stage_instance_update
	// Stage instance was deleted (stage channel no longer live)
	stage_instance_delete
	// Sticker was created
	sticker_create                              = 90
	// Sticker details were updated
	sticker_update
	// Sticker was deleted
	sticker_delete
	// Event was created
	guild_scheduled_event_create                = 100
	// Event was updated
	guild_scheduled_event_update
	// Event was cancelled
	guild_scheduled_event_delete
	// Thread was created in a channel
	thread_create                               = 110
	// Thread was updated
	thread_update
	// Thread was deleted
	thread_delete
	// Permissions were updated for a command
	application_command_permission_update       = 121
	// Auto Moderation rule was created
	auto_moderation_rule_create                 = 140
	// Auto Moderation rule was updated
	auto_moderation_rule_update
	// Auto Moderation rule was deleted
	auto_moderation_rule_delete
	// Message was blocked by Auto Moderation
	auto_moderation_block_message
	// Message was flagged by Auto Moderation
	auto_moderation_flag_to_channel
	// Member was timed out by Auto Moderation
	auto_moderation_user_communication_disabled
	// Creator monetization request was created
	creator_monetization_request_created        = 150
	// Creator monetization terms were accepted
	creator_monetization_terms_accepted
	// Guild Onboarding Question was created
	onboarding_question_create                  = 163
	// Guild Onboarding Question was updated
	onboarding_question_update
	// Guild Onboarding was updated
	onboarding_update                           = 167
	// Guild Server Guide was created
	server_guide_create                         = 190
	// Guild Server Guide was updated
	server_guide_update
}

The table below lists audit log events and values (the action_type field) that your app may receive. The Object Changed column notes which object's values may be included in the entry. Though there are exceptions, possible keys in the changes array typically correspond to the object's fields. The descriptions and types for those fields can be found in the linked documentation for the object. If no object is noted, there won't be a changes array in the entry, though other fields like the target_id still exist and many have fields in the options array.

enum ButtonStyle {
	// blurple
	primary   = 1
	// grey
	secondary = 2
	// green
	success   = 3
	// red
	danger    = 4
	// grey, navigates to a URL
	link      = 5
}

fn (bs ButtonStyle) build() json2.Any

enum ChannelFlags {
	reserved_0
	// this thread is pinned to the top of its parent `.guild_forum` or `.guild_media` channel
	pinned
	reserved_2
	reserved_3
	// whether a tag is required to be specified when creating a thread in a `.guild_forum` or a `.guild_media` channel. Tags are specified in the `applied_tags` field.
	require_tag
	reserved_5
	reserved_6
	reserved_7
	reserved_8
	reserved_9
	reserved_10
	reserved_11
	reserved_12
	reserved_13
	reserved_14
	hide_media_download_options
}

enum ChannelType {
	// unknown type
	unknown             = -1
	// a text channel within a server
	guild_text          = 0
	// a direct message between users
	dm
	// a voice channel within a server
	guild_voice
	// a direct message between multiple users
	group_dm
	// an organizational category that contains up to 50 channels
	guild_category
	// a channel that users can follow and crosspost into their own server (formerly news channels)
	guild_announcement
	// a temporary sub-channel within a GUILD_ANNOUNCEMENT channel
	announcement_thread = 10
	// a temporary sub-channel within a GUILD_TEXT or GUILD_FORUM channel
	public_thread
	// a temporary sub-channel within a GUILD_TEXT channel that is only viewable by those invited and those with the MANAGE_THREADS permission
	private_thread
	// a voice channel for hosting events with an audience
	guild_stage_voice
	// the channel in a hub containing the listed servers
	guild_directory
	// Channel that can only contain threads
	guild_forum
	// Channel that can only contain threads, similar to GUILD_FORUM channels
	guild_media
}

enum ComponentType {
	// Container for other components
	action_row         = 1
	// Button object
	button             = 2
	// Select menu for picking from defined text options
	string_select      = 3
	// Text input object
	text_input         = 4
	// Select menu for users
	user_select        = 5
	// Select menu for roles
	role_select        = 6
	// Select menu for mentionables (users *and roles*)
	mentionable_select = 7
	// Select menu for channels
	channel_select     = 8
}

fn (ct ComponentType) build() json2.Any

enum DefaultValueType {
	user
	role
	channel
}

enum EntitlementType {
	// Entitlement was purchased as an app subscription
	application_subscription = 8
}

enum EventType {
	// when a member sends or edits a message in the guild
	message_send = 1
}

Indicates in what event context a rule should be checked.

enum ExplicitContentFilterLevel {
	// media content will not be scanned
	disabled
	// media content sent by members without roles will be scanned
	members_without_roles
	// media content sent by all members will be scanned
	all_members
}

enum ForumLayoutType {
	// No default has been set for forum channel
	not_set
	// Display posts as a list
	list_view
	// Display posts as a collection of tiles
	gallery_view
}

enum GatewayClientSettings {
	ignore_unknown_events
	dont_process
	dont_cut_debug
	dont_process_guild_events
	no_info_block
	dont_spawn_events
}

enum GatewayIntents {
	guilds
	guild_members
	guild_moderation
	guild_emojis_and_stickers
	guild_integrations
	guild_webhooks
	guild_invites
	guild_voice_states
	guild_presences
	guild_messages
	guild_message_reactions
	guild_message_typing
	direct_messages
	direct_message_reactions
	direct_message_typing
	message_content
	guild_scheduled_events
	reserved_17
	reserved_18
	reserved_19
	auto_moderation_configuration
	auto_moderation_execution
}

enum GatewayOpcode {
	// An event was dispatched.
	dispatch              = 0
	// Fired periodically by the client to keep the connection alive.
	heartbeat
	// Starts a new session during the initial handshake.
	identify
	// Update the client's presence.
	update_presence
	// Used to join/leave or move between voice channels.
	voice_state_update
	// Resume a previous session that was disconnected.
	resume                = 6
	// You should attempt to reconnect and resume immediately.
	reconnect
	// Request information about offline guild members in a large guild.
	request_guild_members
	// The session has been invalidated. You should reconnect and identify/resume accordingly.
	invalid_session
	// Sent immediately after connecting, contains the `heartbeat_interval` to use.
	hello
	// Sent in response to receiving a heartbeat to acknowledge that it has been received.
	heartbeat_ack
}

enum GuildMemberFlags {
	// Member has left and rejoined the guild
	did_rejoin
	// Member has completed onboarding
	completed_onboarding
	// Member is exempt from guild verification requirements
	bypasses_verification
	// Member has started onboarding
	started_onboarding
}

enum GuildScheduledEventEntityType {
	stage_instance = 1
	voice
	external
}

enum GuildScheduledEventPrivacyLevel {
	// the scheduled event is only accessible to guild members
	guild_only = 2
}

enum GuildScheduledEventStatus {
	scheduled = 1
	active
	completed
	canceled
}

enum ImageFormat {
	png
	jpg
	jpeg
	webp
	lottie
	gif
}

enum IntegrationExpireBehavior {
	remove_role
	kick
}

enum InteractionResponseType {
	// ACK a `Ping`
	pong                                    = 1
	// respond to an interaction with a message
	channel_message_with_source             = 4
	// ACK an interaction and edit a response later, the user sees a loading state
	deferred_channel_message_with_source
	// for components, ACK an interaction and edit the original message later; the user does not see a loading state
	deferred_update_message
	// for components, edit the message the component was attached to
	update_message
	// respond to an autocomplete interaction with suggested choices
	application_command_autocomplete_result
	// respond to an interaction with a popup modal
	modal
	// respond to an interaction with an upgrade button, only available for apps with monetization enabled
	premium_required
}

enum InteractionType {
	ping                             = 1
	application_command
	message_component
	application_command_autocomplete
	modal_submit
}

enum InviteTargetType {
	stream               = 1
	embedded_application
}

enum InviteType {
	guild
	group_dm
	friend
}

enum KeywordPresetType {
	// words that may be considered forms of swearing or cursing
	profanity      = 1
	// words that refer to sexually explicit behavior or activity
	sexual_content
	// personal insults or words that may be considered hate speech
	slurs
}

enum MFALevel {
	// guild has no MFA/2FA requirement for moderation actions
	none_
	// guild has a 2FA requirement for moderation actions
	elevated
}

enum MembershipState {
	invited  = 1
	accepted
}

enum MessageActivityType {
	join         = 1
	spectate
	listen
	join_request
}

enum MessageFlags {
	crossposted
	is_crosspost
	suppress_embeds
	source_message_deleted
	urgent
	has_thread
	ephemeral
	loading
	failed_to_mention_some_roles_in_thread
	reserved_9
	reserved_10
	reserved_11
	suppress_notifications
	is_voice_message
}

enum MessageNotificationsLevel {
	// members will receive notifications for all messages by default
	all_messages
	// members will receive notifications only for messages that @mention them by default
	only_mentions
}

enum MessageType {
	default
	recipient_add
	recipient_remove
	call
	channel_name_change
	channel_icon_change
	channel_pinned_message
	user_join
	guild_boost
	guild_boost_tier_1
	guild_boost_tier_2
	guild_boost_tier_3
	channel_follow_add
	guild_discovery_disqualified                = 14
	guild_discovery_requalified
	guild_discovery_grace_period_inital_warning
	guild_discovery_grace_period_final_warning
	thread_created
	reply
	chat_input_command
	thread_starter_message
	guild_invite_reminder
	context_menu_command
	auto_moderation_action
	role_subscription_purchase
	interaction_premium_upsell
	stage_start
	stage_end
	stage_speaker
	stage_topic                                 = 31
	guild_application_premium_subscription
}

enum NSFWLevel {
	default
	explicit
	safe
	age_restricted
}

enum OnboardingMode {
	// Counts only Default Channels towards constraints
	onboarding_default
	// Counts Default Channels and Questions towards constraints
	onboarding_advanced
}

Defines the criteria used to satisfy Onboarding constraints that are required for enabling.

enum OwnerType {
	// for a guild subscription
	guild = 1
	// for a user subscription
	user
}

enum PermissionOverwriteType {
	role
	member
}

enum Permissions as u64 {
	// Allows creation of instant invites
	create_instant_invite
	// Allows kicking members
	kick_members
	// Allows banning members
	ban_members
	// Allows all permissions and bypasses channel permission overwrites
	administrator
	// Allows management and editing of channels
	manage_channels
	// Allows management and editing of the guild
	manage_guild
	// Allows for the addition of reactions to messages
	add_reactions
	// Allows for viewing of audit logs
	view_audit_log
	// Allows for using priority speaker in a voice channel
	priority_speaker
	// Allows the user to go live
	stream
	// Allows guild members to view a channel, which includes reading messages in text channels and joining voice channels
	view_channel
	// Allows for sending messages in a channel and creating threads in a forum (does not allow sending messages in threads)
	send_messages
	// Allows for sending of `/tts` messages
	send_tts_messages
	// Allows for deletion of other users messages
	manage_messages
	// Links sent by users with this permission will be auto-embedded
	embed_links
	// Allows for uploading images and files
	attach_files
	// Allows for reading of message history
	read_message_history
	// Allows for using the `@everyone` tag to notify all users in a channel, and the `@here` tag to notify all online users in a channel
	mention_everyone
	// Allows the usage of custom emojis from other servers
	use_external_emojis
	// Allows for viewing guild insights
	view_guild_insights
	// Allows for joining of a voice channel
	connect
	// Allows for speaking in a voice channel
	speak
	// Allows for muting members in a voice channel
	mute_members
	// Allows for deafening of members in a voice channel
	deafen_members
	// Allows for moving of members between voice channels
	move_members
	// Allows for using voice-activity-detection in a voice channel
	use_vad
	// Allows for modification of own nickname
	change_nickname
	// Allows for modification of other users nicknames
	manage_nicknames
	// Allows management and editing of roles
	manage_roles
	// Allows management and editing of webhooks
	manage_webhooks
	// Allows for editing and deleting emojis, stickers, and soundboard sounds created by all users
	manage_guild_expressions
	// Allows members to use application commands, including slash commands and context menu commands.
	use_application_commands
	// Allows for requesting to speak in stage channels. (This permission is under active development and may be changed or removed.)
	request_to_speak
	// Allows for editing and deleting scheduled events created by all users
	manage_events
	// Allows for deleting and archiving threads, and viewing all private threads
	manage_threads
	// Allows for creating public and announcement threads
	create_public_threads
	// Allows for creating private threads
	create_private_threads
	// Allows the usage of custom stickers from other servers
	use_external_stickers
	// Allows for sending messages in threads
	send_messages_in_threads
	// Allows for using Activities (applications with the `EMBEDDED` flag) in a voice channel
	use_embedded_activities
	// Allows for timing out users to prevent them from sending or reacting to messages in chat and threads, and from speaking in voice and stage channels
	moderate_members
	// Allows for viewing role subscription insights
	view_creator_monetization_analytics
	// Allows for using soundboard in a voice channel
	use_soundboard
	// Allows for creating emojis, stickers, and soundboard sounds, and editing and deleting those created by the current user
	create_guild_expressions
	// Allows for creating scheduled events, and editing and deleting those created by the current user
	create_events
	// Allows the usage of custom soundboard sounds from other servers
	use_external_sounds
	// Allows sending voice messages
	send_voice_messages
}

enum PremiumTier {
	// guild has not unlocked any Server Boost perks
	none_
	// guild has unlocked Server Boost level 1 perks
	tier_1
	// guild has unlocked Server Boost level 2 perks
	tier_2
	// guild has unlocked Server Boost level 3 perks
	tier_3
}

enum PremiumType {
	// None
	none_
	// Nitro Classic
	nitro_classic
	// Nitro
	nitro
	// Nitro Basic
	nitro_basic
}

enum PrivacyLevel {
	// The Stage instance is visible to only guild members.
	guild_only = 2
}

enum PromptType {
	multiple_choice
	dropdown
}

enum ReactionType {
	normal
	burst
}

enum RoleFlags {
	// role can be selected by members in an onboarding prompt
	in_prompt
}

enum SkuFlags {
	reserved_0
	reserved_1
	// SKU is available for purchase
	available
	reserved_3
	reserved_4
	reserved_5
	reserved_6
	// Recurring SKU that can be purchased by a user and applied to a single server. Grants access to every user in that server.
	guild_subscription
	// Recurring SKU purchased by a user for themselves. Grants access to the purchasing user in every server.
	user_subscription
}

enum SkuType {
	// Represents a recurring subscription
	subscription       = 5
	// System-generated group for each SUBSCRIPTION SKU created
	subscription_group
}

enum SortOrderType {
	// Sort forum posts by activity
	latest_activity
	// Sort forum posts by creation time (from most recent to oldest)
	creation_date
}

enum Status {
	// Online (Green)
	online
	// Do Not Disturb (Red)
	dnd
	// AFK (Yellow)
	idle
	// Invisible and shown as offline (Gray)
	invisible
	// Offline (Gray)
	offline
}

fn (s Status) build() string

enum StickerFormatType {
	png
	apng
	lottie
	gif
}

enum StickerType {
	standard
	guild
}

enum SystemChannelFlags {
	// Suppress member join notifications
	suppress_join_notifications
	// Suppress server boost notifications
	suppress_premium_subscriptions
	// Suppress server setup tips
	suppress_guild_reminder_notifications
	// Hide member join sticker reply buttons
	suppress_join_notification_replies
	// Suppress role subscription purchase and renewal notifications
	suppress_role_subscription_purchase_notifications
	// Hide role subscription sticker reply buttons
	suppress_role_subscription_purchase_notifications_replies
}

enum TextInputStyle {
	// Single-line input
	short     = 1
	// Multi-line input
	paragraph = 2
}

fn (tis TextInputStyle) build() json2.Any

enum TriggerType {
	// check if content contains words from a user defined list of keywords
	keyword        = 1
	// check if content represents generic spam
	spam           = 3
	// check if content contains words from internal pre-defined wordsets
	keyword_preset
	// check if content contains more unique mentions than allowed
	mention_spam
}

Characterizes the type of content which can trigger the rule.

enum UserFlags {
	// Discord Employee
	staff
	// Partnered Server Owner
	partner
	// HypeSquad Events Member
	hypesquad
	// Bug Hunter Level 1
	bug_hunter_level_1
	reserved_4
	reserved_5
	// House Bravery Member
	hypesquad_online_house_1
	// House Brilliance Member
	hypesquad_online_house_2
	// House Balance Member
	hypesquad_online_house_3
	// Early Nitro Supporter
	premium_early_supporter
	// User is a team
	team_pseudo_user
	reserved_11
	reserved_12
	reserved_13
	// Bug Hunter Level 2
	bug_hunter_level_2
	reserved_15
	// Verified Bot
	verified_bot
	// Early Verified Bot Developer
	verified_developer
	// Moderator Programs Alumni
	certified_moderator
	// Bot uses only HTTP interactions and is shown in the online member list
	bot_http_interactions
	reserved_20
	reserved_21
	// User is an Active Developer
	active_developer
}

enum VerificationLevel {
	// unrestricted
	none_
	// must have verified email on account
	low
	// must be registered on Discord for longer than 5 minutes
	medium
	// must be a member of the server for longer than 10 minutes
	high
	// must have a verified phone number
	very_high
}

enum VideoQualityMode {
	// Discord chooses the quality for optimal performance
	auto = 1
	// 720p
	full
}

enum Visibility {
	// invisible to everyone except the user themselves
	none_
	// visible to everyone
	everyone
}

enum WebhookType {
	// Incoming Webhooks can post messages to channels with a generated token
	incoming         = 1
	// Channel Follower Webhooks are internal webhooks used with Channel Following to post new messages into channels
	channel_follower
	// Application webhooks are webhooks used with Interactions
	application
}

struct Action {
pub:
	// the type of action
	typ ActionType
	// additional metadata needed during execution for this specific action type
	metadata ?ActionMetadata
}

fn (a Action) build() json2.Any

struct ActionMetadata {
pub:
	// channel to which user content should be logged
	channel_id ?Snowflake
	// timeout duration in seconds
	duration_seconds ?time.Duration
	// additional explanation that will be shown to members whenever their message is blocked
	custom_message ?string
}

fn (am ActionMetadata) build() json2.Any

struct ActionRow {
pub:
	components []Component
}

An Action Row is a non-interactive container component for other types of components. It has a sub-array of components of other types.- You can have up to 5 Action Rows per message

• An Action Row cannot contain another Action Row

fn (ar ActionRow) build() json2.Any

struct Activity {
pub:
	// Activity's name
	name string
	// Activity type
	typ ActivityType @[required]
	// Stream URL, is validated when type is 1
	url ?NullOr[string]
	// Unix timestamp (in milliseconds) of when the activity was added to the user's session
	created_at time.Time
	// Unix timestamps for start and/or end of the game
	timestamps ?ActivityTimestamps
	// Application ID for the game
	application_id ?Snowflake
	// What the player is currently doing
	details ?NullOr[string]
	// User's current party status, or text used for a custom status
	state ?NullOr[string]
	// Emoji used for a custom status
	emoji ?NullOr[ActivityEmoji]
	// Information for the current party of the player
	party ?ActivityParty
	// Images for the presence and their hover texts
	assets ?ActivityAssets
	// Secrets for Rich Presence joining and spectating
	secrets ?ActivitySecrets
	// Whether or not the activity is an instanced game session
	instance ?bool
	// Activity flags `OR`d together, describes what the payload includes
	flags ?ActivityFlags
	// Custom buttons shown in the Rich Presence (max 2)
	buttons ?[]ActivityButton
}

fn (a Activity) build() json2.Any

struct ActivityAssets {
pub:
	// See [Activity Asset Image](https://discord.com/developers/docs/topics/gateway-events#activity-object-activity-asset-image)
	large_image ?string
	// Text displayed when hovering over the large image of the activity
	large_text ?string
	// // See [Activity Asset Image](https://discord.com/developers/docs/topics/gateway-events#activity-object-activity-asset-image)
	small_image ?string
	// Text displayed when hovering over the small image of the activity
	small_text ?string
}

struct ActivityButton {
pub:
	// Text shown on the button (1-32 characters)
	label string
	// URL opened when clicking the button (1-512 characters)
	url string
}

struct ActivityEmoji {
pub:
	// Name of the emoji
	name string
	// ID of the emoji
	id ?Snowflake
	// Whether the emoji is animated
	animated ?bool
}

struct ActivityParty {
pub:
	// ID of the party
	id ?string
	// Used to show the party's current size
	current_size ?int
	// Used to show the party's maximum size
	max_size ?int
}

struct ActivitySecrets {
pub:
	// Secret for joining a party
	join ?string
	// Secret for spectating a game
	spectate ?string
	// Secret for a specific instanced match
	match_ ?string
}

struct ActivityTimestamps {
pub:
	// Unix time (in milliseconds) of when the activity started
	start ?time.Time
	// Unix time (in milliseconds) of when the activity ends
	end ?time.Time
}

struct AddGuildMemberParams {
pub mut:
	// an oauth2 access token granted with the `guilds.join` to the bot's application for the user you want to add to the guild
	access_token string @[required]
	// value to set user's nickname to
	nick ?string
	// array of role ids the member is assigned
	roles ?[]Snowflake
	// whether the user is muted in voice channels
	mute ?bool
	// whether the user is deafened in voice channels
	deaf ?bool
}

fn (params AddGuildMemberParams) build() json2.Any

struct AllowedMentions {
pub:
	// An array of allowed mention types to parse from the content.
	parse ?[]AllowedMentionType
	// Array of role_ids to mention (Max size of 100)
	roles ?[]Snowflake
	// Array of user_ids to mention (Max size of 100)
	users ?[]Snowflake
	// For replies, whether to mention the author of the message being replied to (default false)
	replied_user ?bool
}

fn (am AllowedMentions) build() json2.Any

struct ApngImage {
pub:
	data []u8 @[required]
}

fn (_ ApngImage) content_type() string

fn (af ApngImage) build() string

struct Application {
pub:
	// ID of the app
	id Snowflake
	// Name of the app
	name string
	// Icon hash of the app
	icon ?string
	// Description of the app
	description string
	// List of RPC origin URLs, if RPC is enabled
	rpc_origins ?[]string
	// When `false`, only the app owner can add the app to guilds
	bot_public bool
	// When `true`, the app's bot will only join upon completion of the full OAuth2 code grant flow
	bot_require_code_grant bool
	// Partial user object for the bot user associated with the app
	bot ?User
	// URL of the app's Terms of Service
	terms_of_service_url ?string
	// URL of the app's Privacy Policy
	privacy_policy_url ?string
	// Partial user object for the owner of the app
	owner ?User
	// Key for verification in interactions and the GameSDK's GetTicket
	verify_key []u8
	// If the app belongs to a team, this will be a list of the members of that team
	team ?Team
	// Guild associated with the app. For example, a developer support server.
	guild_id ?Snowflake
	// Partial object of the associated guild
	guild ?PartialGuild
	// If this app is a game sold on Discord, this field will be the id of the "Game SKU" that is created, if exists
	primary_sku_id ?Snowflake
	// If this app is a game sold on Discord, this field will be the URL slug that links to the store page
	slug ?string
	// App's default rich presence invite cover image hash
	cover_image ?string
	// App's public flags
	flags ?ApplicationFlags
	// Approximate count of guilds the app has been added to
	approximate_guild_count ?int
	// Array of redirect URIs for the app
	redirect_uris ?[]string
	// Interactions endpoint URL for the app
	interactions_endpoint_url ?string
	// Role connection verification URL for the app
	role_connections_verification_url ?string
	// List of tags describing the content and functionality of the app. Max of 5 tags.
	tags ?[]string
	// Settings for the app's default in-app authorization link, if enabled
	install_params ?InstallParams
	// Default custom authorization URL for the app, if enabled
	custom_install_url ?string
}

struct ApplicationCommand {
pub:
	// Unique ID of command
	id Snowflake
	// Type of command, defaults to 1
	typ ApplicationCommandType = .chat_input
	// ID of the parent application
	application_id Snowflake
	// Guild ID of the command, if not global
	guild_id ?Snowflake
	// Name of command, 1-32 characters
	name string
	// Localization dictionary for `name` field. Values follow the same restrictions as `name`
	name_localizations ?map[Locale]string
	// Description for `.chat_input` commands, 1-100 characters. Empty string for `.user` and `.message` commands
	description string
	// Localization dictionary for `description` field. Values follow the same restrictions as `description`
	description_localizations ?map[Locale]string
	// Parameters for the command, max of 25
	options ?[]ApplicationCommandOption
	// Set of permissions represented as a bit set
	default_member_permissions ?Permissions
	// Indicates whether the command is available in DMs with the app, only for globally-scoped commands. By default, commands are visible.
	dm_permission ?bool
	// Indicates whether the command is age-restricted, defaults to `false`
	nsfw ?bool
}

struct ApplicationCommandData {
pub:
	// the ID of the invoked command
	id Snowflake
	// the name of the invoked command
	name string
	// the type of the invoked command
	typ ApplicationCommandType
	// converted users + roles + channels + attachments
	resolved ?Resolved
	// the params + values from the user
	options ?[]ApplicationCommandInteractionDataOption
	// the id of the guild the command is registered to
	guild_id ?Snowflake
	// id of the user or message targeted by a user or message command
	target_id ?Snowflake
}

fn (acd ApplicationCommandData) get(option string) ?ApplicationCommandInteractionDataOptionValue

struct ApplicationCommandInteractionDataOption {
pub:
	// Name of the parameter
	name string
	// Value of application command option type
	typ ApplicationCommandOptionType
	// Value of the option resulting from user input
	value ?ApplicationCommandInteractionDataOptionValue
	// Present if this option is a group or subcommand
	options ?[]ApplicationCommandInteractionDataOption
	// true if this option is the currently focused option for autocomplete
	focused ?bool
}

struct ApplicationCommandOption {
pub:
	// Type of option
	typ ApplicationCommandOptionType @[required]
	// 1-32 character name
	name string @[required]
	// Localization dictionary for the `name` field. Values follow the same restrictions as `name`
	name_localizations ?map[Locale]string
	// 1-100 character description
	description string @[required]
	// Localization dictionary for the `description` field. Values follow the same restrictions as `description`
	description_localizations ?map[Locale]string
	// If the parameter is required or optional--default `false`
	required ?bool
	// Choices for `.string`, `.integer`, and `.number` types for the user to pick from, max 25
	choices ?[]ApplicationCommandOptionChoice
	// If the option is a subcommand or subcommand group type, these nested options will be the parameters
	options ?[]ApplicationCommandOption
	// If the option is a channel type, the channels shown will be restricted to these types
	channel_types ?[]ChannelType
	// If the option is an `.integer` or `.number` type, the minimum value permitted
	min_value ?Number
	// If the option is an `.integer` or `.number` type, the maximum value permitted
	max_value ?Number
	// For option type `.string`, the minimum allowed length (minimum of `0`, maximum of `6000`)
	min_length ?int
	// For option type `.string`, the maximum allowed length (minimum of `1`, maximum of `6000`)
	max_length ?int
	// If autocomplete interactions are enabled for this `.string`, `.integer`, or `.number` type option
	autocomplete ?bool
}

fn (aco ApplicationCommandOption) build() json2.Any

struct ApplicationCommandOptionChoice {
pub:
	// 1-100 character choice name
	name string @[required]
	// Localization dictionary for the `name` field. Values follow the same restrictions as `name`
	name_localizations ?map[Locale]string
	// Value for the choice, up to 100 characters if string
	value ApplicationCommandOptionChoiceValue @[required]
}

fn (acoc ApplicationCommandOptionChoice) build() json2.Any

struct ApplicationCommandPermission {
pub:
	// ID of the role, user, or channel. It can also be a permission constant
	id Snowflake
	// role (`.role`), user (`.user`), or channel (`.channel`)
	typ ApplicationCommandPermissionType
	// `true` to allow, `false`, to disallow
	permission bool
}

fn (acp ApplicationCommandPermission) build() json2.Any

struct ApplicationCommandPermissionsUpdateEvent {
	BaseEvent
pub:
	permissions GuildApplicationCommandPermissions
}

struct ApplicationRoleConnection {
pub:
	// the vanity name of the platform a bot has connected (max 50 characters)
	platform_name ?string
	// the username on the platform a bot has connected (max 100 characters)
	platform_username ?string
	// object mapping [application role connection metadata](#ApplicationRoleConnectionMetadata) keys to their string-ified value (max 100 characters) for the user on the platform a bot has connected
	metadata map[string]string
}

struct ApplicationRoleConnectionMetadata {
pub:
	// type of metadata value
	typ ApplicationRoleConnectionMetadataType
	// dictionary key for the metadata field (must be `a-z`, `0-9`, or `_` characters; 1-50 characters)
	key string
	// name of the metadata field (1-100 characters)
	name string
	// translations of the name
	name_localizations ?map[Locale]string
	// description of the metadata field (1-200 characters)
	description string
	// translations of the description
	description_localizations ?map[Locale]string
}

struct Attachment {
pub:
	// attachment id
	id Snowflake
	// name of file attached
	filename string
	// description for the file (max 1024 characters)
	description ?string
	// the attachment's media type
	content_type ?string
	// size of file in bytes
	size int
	// source url of file
	url string
	// a proxied url of file
	proxy_url string
	// height of file (if image)
	height ?int
	// width of file (if image)
	width ?int
	// whether this attachment is ephemeral
	ephemeral ?bool
	// the duration of the audio file (currently for voice messages)
	duration_secs ?time.Duration
	// base64 encoded bytearray representing a sampled waveform (currently for voice messages)
	waveform ?[]u8
	// attachment flags combined as a bitfield
	flags ?AttachmentFlags
}

struct AuditEntryInfo {
pub:
	// ID of the app whose permissions were targeted
	application_id ?Snowflake
	// Name of the Auto Moderation rule that was triggered
	auto_moderation_rule_name ?string
	// Trigger type of the Auto Moderation rule that was triggered
	auto_moderation_rule_trigger_type ?string
	// Channel in which the entities were targeted
	channel_id ?Snowflake
	// Number of entities that were targeted
	count ?string
	// Number of days after which inactive members were kicked
	delete_member_days ?string
	// ID of the overwritten entity
	id ?Snowflake
	// Number of members removed by the prune
	members_removed ?string
	// ID of the message that was targeted
	message_id ?Snowflake
	// Name of the role if type is "0" (not present if type is "1")
	role_name ?string
	// Type of overwritten entity - role ("0") or member ("1")
	typ ?string
	// The type of integration which performed the action
	integration_type ?string
}

struct AuditLog {
pub:
	// List of application commands referenced in the audit log
	application_commands []ApplicationCommand
	// List of audit log entries, sorted from most to least recent
	audit_log_entries []AuditLogEntry
	// List of auto moderation rules referenced in the audit log
	auto_moderation_rules []AutoModerationRule
	// List of guild scheduled events referenced in the audit log
	guild_scheduled_events []GuildScheduledEvent
	// List of partial integration objects
	integrations []PartialIntegration
	// List of threads referenced in the audit log
	threads []Channel
	// List of users referenced in the audit log
	users []User
	// List of webhooks referenced in the audit log
	webhooks []Webhook
}

When an administrative action is performed in a guild, an entry is added to its audit log. Viewing audit logs requires the .view_audit_log permission and can be fetched by apps using the GET /guilds/{guild.id}/audit-logs endpoint, or seen by users in the guild's Server Settings. All audit log entries are stored for 45 days. When an app is performing an eligible action using the APIs, it can pass an reason param to indicate why the action was taken. More information is in the audit log entry section.

struct AuditLogChange {
pub:
	// New value of the key
	new_value ?json2.Any
	// Old value of the key
	old_value ?json2.Any
	// Name of the changed entity, with a few exceptions
	key string
}

struct AuditLogEntry {
pub:
	// ID of the affected entity (webhook, user, role, etc.)
	target_id ?string
	// Changes made to the `target_id`
	changes ?[]AuditLogChange
	// User or app that made the changes
	user_id ?Snowflake
	// ID of the entry
	id Snowflake
	// Type of action that occurred
	action_type AuditLogEvent
	// Additional info for certain event types
	options ?AuditEntryInfo
	// Reason for the change (1-512 characters)
	reason ?string
}

Each audit log entry represents a single administrative action (or event), indicated by action_type. Most entries contain one to many changes in the changes array that affected an entity in Discord—whether that's a user, channel, guild, emoji, or something else. The information (and structure) of an entry's changes will be different depending on its type. For example, in .member_role_update events there is only one change: a member is either added or removed from a specific role. However, in .channel_create events there are many changes, including (but not limited to) the channel's name, type, and permission overwrites added. More details are in the change object section. Apps can specify why an administrative action is being taken by passing an X-Audit-Log-Reason request header, which will be stored as the audit log entry's reason field. The X-Audit-Log-Reason header supports 1-512 URL-encoded UTF-8 characters. Reasons are visible to users in the client and to apps when fetching audit log entries with the API.

struct AutoModerationActionExecutionEvent {
	BaseEvent
pub:
	// ID of the guild in which action was executed
	guild_id Snowflake
	// Action which was executed
	action Action
	// ID of the rule which action belongs to
	rule_id Snowflake
	// Trigger type of rule which was triggered
	rule_trigger_type TriggerType
	// ID of the user which generated the content which triggered the rule
	channel_id ?Snowflake
	// ID of any user message which content belongs to
	message_id ?Snowflake
	// ID of any system auto moderation messages posted as a result of this action
	alert_system_message_id ?Snowflake
	// User-generated text content
	content string
	// Word or phrase configured in the rule that triggered the rule
	matched_keyword ?string
	// Substring in content that triggered the rule
	matched_content ?string
}

struct AutoModerationRule {
pub:
	// the id of this rule
	id Snowflake
	// the id of the guild which this rule belongs to
	guild_id Snowflake
	// the rule name
	name string
	// the user which first created this rule
	creator_id Snowflake
	// the rule event type
	event_type EventType
	// the rule trigger type
	trigger_type TriggerType
	// the rule trigger metadata
	trigger_metadata TriggerMetadata
	// the actions which will execute when the rule is triggered
	actions []Action
	// whether the rule is enabled
	enabled bool
	// the role ids that should not be affected by the rule (Maximum of 20)
	exempt_roles []Snowflake
	// the channel ids that should not be affected by the rule (Maximum of 50)
	exempt_channels []Snowflake
}

struct AutoModerationRuleCreateEvent {
	BaseEvent
pub:
	rule AutoModerationRule
}

struct AutoModerationRuleDeleteEvent {
	BaseEvent
pub:
	rule AutoModerationRule
}

struct AutoModerationRuleUpdateEvent {
	BaseEvent
pub:
	rule AutoModerationRule
}

struct AutocompleteInteractionResponse {
	AutocompleteResponseData
}

fn (air AutocompleteInteractionResponse) get_files() ?[]File

fn (air AutocompleteInteractionResponse) build() json2.Any

struct AutocompleteResponseData {
pub mut:
	// autocomplete choices (max of 25 choices)
	choices []ApplicationCommandOptionChoice @[required]
}

fn (_ AutocompleteResponseData) is_interaction_response_data()

fn (_ AutocompleteResponseData) get_files() ?[]File

fn (ard AutocompleteResponseData) build() json2.Any

struct AvatarDecorationData {
pub:
	asset  string
	sku_id Snowflake
}

struct Ban {
pub:
	// the reason for the ban
	reason ?string
	// the banned user
	user User
}

struct BaseEvent {
pub mut:
	creator &GatewayClient
}

struct BeginGuildPruneParams {
pub mut:
	// number of days to prune (1-30)
	days ?int
	// whether `pruned` is returned, discouraged for large guilds
	compute_prune_count ?bool
	// role(s) to include
	with_roles []Snowflake
	// reason for the prune
	reason ?string
}

fn (params BeginGuildPruneParams) build() json2.Any

struct BotConfig {
	RESTConfig
pub:
	cache           Cache
	debug           bool
	intents         GatewayIntents
	properties      Properties
	large_threshold ?int
	presence        ?UpdatePresenceParams
	read_timeout    ?time.Duration
	settings        GatewayClientSettings
	write_timeout   ?time.Duration
}

struct BulkBanResponse {
pub:
	// list of user ids, that were successfully banned
	banned_users ?[]Snowflake
	// list of user ids, that were not banned
	failed_users ?[]Snowflake
}

struct BulkGuildBanParams {
pub mut:
	reason   ?string
	user_ids []Snowflake @[required]
	// number of seconds to delete messages for, between 0 and 604800 (7 days)
	delete_message_seconds ?time.Duration
}

fn (params BulkGuildBanParams) build() json2.Any

struct Button {
pub:
	// A button style, default is `.secondary`
	style ButtonStyle = .secondary
	// Text that appears on the button; max 80 characters
	label ?string
	// `name`, `id`, and `animated`
	emoji ?ComponentEmoji
	// Developer-defined identifier for the button; max 100 characters
	custom_id ?string
	// URL for link-style buttons
	url ?string
	// Whether the button is disabled (defaults to false)
	disabled ?bool
}

Buttons are interactive components that render in messages. They can be clicked by users, and send an interaction to your app when clicked.

• Buttons must be sent inside an Action Row
• An Action Row can contain up to 5 buttons
• An Action Row containing buttons cannot also contain any select menu components
  

Buttons come in a variety of styles to convey different types of actions. These styles also define what fields are valid for a button.

• Non-link buttons must have a custom_id, and cannot have a url
• Link buttons must have a url, and cannot have a custom_id
• Link buttons do not send an interaction to your app when clicked

fn (b Button) build() json2.Any

struct CDN {
pub:
	base string
}

fn (c CDN) custom_emoji(emoji_id Snowflake, params CDNGetParams) string

fn (c CDN) guild_icon(guild_id Snowflake, guild_icon string, params CDNGetParams) string

fn (c CDN) guild_splash(guild_id Snowflake, guild_icon string, params CDNGetParams) string

fn (c CDN) guild_discovery_splash(guild_id Snowflake, guild_icon string, params CDNGetParams) string

fn (c CDN) guild_banner(guild_id Snowflake, guild_banner string, params CDNGetParams) string

fn (c CDN) user_banner(user_id Snowflake, user_banner string, params CDNGetParams) string

fn (c CDN) default_user_avatar(index int) string

fn (c CDN) user_avatar(user_id Snowflake, user_avatar string, params CDNGetParams) string

fn (c CDN) guild_member_avatar(guild_id Snowflake, user_id Snowflake, member_avatar string, params CDNGetParams) string

fn (c CDN) user_avatar_decoration(user_id Snowflake, user_avatar_decoration string, params CDNGetParams) string

fn (c CDN) application_icon(application_id Snowflake, icon string, params CDNGetParams) string

fn (c CDN) application_cover(application_id Snowflake, cover_image string, params CDNGetParams) string

fn (c CDN) application_asset(application_id Snowflake, asset_id string, params CDNGetParams) string

fn (c CDN) achievement_icon(application_id Snowflake, achievement_id string, icon_hash string, params CDNGetParams) string

fn (c CDN) store_page_asset(application_id Snowflake, asset_id string, params CDNGetParams) string

fn (c CDN) sticker_pack_banner(application_id Snowflake, sticker_pack_banner_asset_id Snowflake, params CDNGetParams) string

fn (c CDN) team_icon(team_id Snowflake, team_icon string, params CDNGetParams) string

fn (c CDN) sticker(sticker_id Snowflake, params CDNGetParams) string

fn (c CDN) role_icon(role_id Snowflake, role_icon string, params CDNGetParams) string

fn (c CDN) guild_scheduled_event_cover(scheduled_event_id Snowflake, scheduled_event_cover_image string, params CDNGetParams) string

fn (c CDN) guild_member_banner(guild_id Snowflake, user_id Snowflake, member_banner string, params CDNGetParams) string

struct CDNAttachment {
	// Timestamp indicating when an attachment CDN URL will expire
	expires_on time.Time
	// Timestamp indicating when the URL was issued
	issued_at time.Time
	// Unique signature that remains valid until the URL's expiration
	unique_signature []u8
}

struct CDNGetParams {
pub mut:
	format ?ImageFormat
	size   ?int
}

fn (params CDNGetParams) build() string

struct Cache {
pub:
	guilds_check    fn (guild_id Snowflake, guild Guild) bool = unsafe { nil }
	guilds_max_size ?int = 0

	roles_check     fn (guild_id Snowflake, role_id Snowflake, role Role) bool = unsafe { nil }
	roles_max_size1 ?int = 0
	roles_max_size2 ?int = 0

	emojis_check     fn (guild_id Snowflake, emoji_id Snowflake, emoji Emoji) bool = unsafe { nil }
	emojis_max_size1 ?int = 0
	emojis_max_size2 ?int = 0

	stickers_check     fn (guild_id Snowflake, sticker_id Snowflake, sticker Sticker) bool = unsafe { nil }
	stickers_max_size1 ?int = 0
	stickers_max_size2 ?int = 0

	auto_moderation_rules_check     fn (guild_id Snowflake, rule_id Snowflake, rule AutoModerationRule) bool = unsafe { nil }
	auto_moderation_rules_max_size1 ?int = 0
	auto_moderation_rules_max_size2 ?int = 0

	voice_states_check     fn (guild_id Snowflake, user_id Snowflake, state VoiceState) bool = unsafe { nil }
	voice_states_max_size1 ?int = 0
	voice_states_max_size2 ?int = 0

	members_check     fn (guild_id Snowflake, user_id Snowflake, member GuildMember) bool = unsafe { nil }
	members_max_size1 ?int = 0
	members_max_size2 ?int = 0

	channels_check    fn (channel_id Snowflake, channel Channel) bool = unsafe { nil }
	channels_max_size ?int = 0

	messages_check     fn (channel_id Snowflake, message_id Snowflake, message Message) bool = unsafe { nil }
	messages_max_size1 ?int = 0
	messages_max_size2 ?int = 0

	threads_check     fn (guild_id Snowflake, thread_id Snowflake, thread Channel) bool = unsafe { nil }
	threads_max_size1 ?int = 0
	threads_max_size2 ?int = 0

	presences_check     fn (guild_id Snowflake, user_id Snowflake, presence Presence) bool = unsafe { nil }
	presences_max_size1 ?int = 0
	presences_max_size2 ?int = 0

	stage_instances_check     fn (guild_id Snowflake, instance_id Snowflake, instance StageInstance) bool = unsafe { nil }
	stage_instances_max_size1 ?int = 0
	stage_instances_max_size2 ?int = 0

	guild_scheduled_events_check     fn (guild_id Snowflake, event_id Snowflake, event GuildScheduledEvent) bool = unsafe { nil }
	guild_scheduled_events_max_size1 ?int = 0
	guild_scheduled_events_max_size2 ?int = 0

	entitlements_check     fn (owner_id Snowflake, entitlement_id Snowflake, entitlement Entitlement) bool = unsafe { nil }
	entitlements_max_size1 ?int = 0
	entitlements_max_size2 ?int = 0

	users_check    fn (user_id Snowflake, user User) bool = unsafe { nil }
	users_max_size ?int
pub mut:
	// {guild_id -> guild}
	guilds map[Snowflake]Guild
	// {guild_id -> {role_id -> role}}
	roles map[Snowflake]map[Snowflake]Role
	// {guild_id -> {emoji_id -> emoji}}
	emojis map[Snowflake]map[Snowflake]Emoji
	// {guild_id -> {sticker_id -> sticker}}
	stickers map[Snowflake]map[Snowflake]Sticker
	// {guild_id -> {rule_id -> rule}}
	auto_moderation_rules map[Snowflake]map[Snowflake]AutoModerationRule
	// {guild_id -> {user_id -> state}}
	voice_states map[Snowflake]map[Snowflake]VoiceState
	// {guild_id -> {user_id -> member}}
	members map[Snowflake]map[Snowflake]GuildMember
	// {channel_id -> channel}
	channels map[Snowflake]Channel
	// {channel_id -> {message_id -> message}}
	messages map[Snowflake]map[Snowflake]Message
	// {guild_id -> {channel_id -> thread}}
	threads map[Snowflake]map[Snowflake]Channel
	// {guild_id -> {user_id -> presence}}
	presences map[Snowflake]map[Snowflake]Presence
	// {guild_id -> {channel_id -> instance}}
	stage_instances map[Snowflake]map[Snowflake]StageInstance
	// {guild_id -> {guild_scheduled_event_id -> guild_scheduled_event}}
	guild_scheduled_events map[Snowflake]map[Snowflake]GuildScheduledEvent
	// {owner_id (user_id | guild_id) -> {entitlement_id -> entitlement}}
	entitlements map[Snowflake]map[Snowflake]Entitlement
	// {user_id -> user}
	users map[Snowflake]User
}

fn (cache &Cache) get_guild(guild_id Snowflake) ?Guild

fn (cache &Cache) get_role(guild_id Snowflake, role_id Snowflake) ?Role

fn (cache &Cache) get_emoji(guild_id Snowflake, emoji_id Snowflake) ?Emoji

fn (cache &Cache) get_sticker(guild_id Snowflake, sticker_id Snowflake) ?Sticker

fn (cache &Cache) get_voice_state(guild_id Snowflake, user_id Snowflake) ?VoiceState

fn (cache &Cache) get_member(guild_id Snowflake, user_id Snowflake) ?GuildMember

fn (cache &Cache) get_channel(channel_id Snowflake) ?Channel

fn (cache &Cache) get_message(channel_id Snowflake, message_id Snowflake) ?Message

fn (cache &Cache) get_thread(guild_id Snowflake, thread_id Snowflake) ?Channel

fn (cache &Cache) get_presence(guild_id Snowflake, user_id Snowflake) ?Presence

fn (cache &Cache) get_stage_instance(guild_id Snowflake, channel_id Snowflake) ?StageInstance

fn (cache &Cache) get_guild_scheduled_event(guild_id Snowflake, guild_scheduled_event_id Snowflake) ?GuildScheduledEvent